Oop

Object Oriented Programming
Uttam K. Roy
Dept. of IT, JU u_roy@it.jusl.ac.in
Books
B. Stroustrup, The C++ Programming Language, Addison Wesley publication E. Balagurusamy, Object Oriented Programming with C++, Tata McGrawHill publication Yashwant Kanetkar, Let Us C++, BPB publication Lipman, C++ Primer
U.K.R., 2008
OOP
What Is C++?
Compatible extension of C Support Object Oriented Programming Support for Data Abstraction
U.K.R., 2008
OOP
Background
C++ designed by Bjarne Stroustrup (AT&T Bell Labs) Originally only meant as a pre-processor to improve on some of the inadequacies of C First commercial release 1985 Even today many consider C++ is not an object oriented language but rather an object oriented compiler-linker (subtle difference we'll learn about later).
U.K.R., 2008 OOP 4
BPCL C Algol68 Algol68 Simula67 Simula67 (Smalltalk) (Ada) (LISP)

U.K.R., 2008 OOP 5
C++
Strengths and Weakness of C

Strengths

Flexible (you can make mistakes in a wide variety of ways!) Efficient (you can make those mistakes very quickly!) Available (everyone can make mistakes together!) Portable (you can transport those mistakes to other systems!) Very untidy syntax Lack of type safety memory management not automatic
OOP 6
Weaknesses

U.K.R., 2008
Philosophy of C++
Keep the strengths and repair the weaknesses

Efficiency is maintained Compatibility is maintained with C Operate in all environments C can Improved typing Abstraction and Data encapsulation vastly improved Inheritance and Polymorphism introduced
U.K.R., 2008
OOP
U.K.R., 2008
OOP
OOP Language?
An Object Oriented Programming Language is one which fully supports the fundamental concepts of Object Oriented approach, namely:

Definition of class and declaration of objects Enforcement of information hiding The ability to define an inheritance hierarchy of classes The ability to code polymorphic methods Invocation of an objects method by message passing
OOP 9
U.K.R., 2008
Examples of OOP Language

Pure Object Oriented Programming Languages

SmallTalk (The first OOPL) Eiffel (powerful language that supports selective inheritance) C++ (does not enforce information hiding) Object Pascal (does not support information hiding and does not support multiple inheritance) Object COBOL (does not enforce information hiding) Visual Basic, Paradox, ToolBook etc.
Languages with OO Extensions

Languages with OO look and feel

U.K.R., 2008
OOP
10
Differences between C and C++

OO programming constructions Function prototyping Default parameter values Reference parameters Enumeration names Use of const Inline functions Block declarations Different syntax for cast operator Function and operator overloading New syntax for comments Operators for I/O streams New libraries
U.K.R., 2008 OOP 11
Key Words for C and C++

C and C++ Key Words auto break case default do double float for goto register return short struct switch typedef volatile while Additional C++ Key Words asm catch class new operator private this throw try char else if signed union const enum int sizeof unsigned continue extern long static void
delete friend protected public virtual
inline template
U.K.R., 2008
OOP
12
Non-Object Oriented Extension from C to C++
Flexible declaration
In C, when you write a function, all the declaration of local variables must appear at the top of the function or at the beginning of a block
#include <iostream.h> main( ) { for(int f = 0; f < 100; f++) { float c = (f 32)*5/9.0; cout << c << << f << \n; } }
U.K.R., 2008 OOP 14
Type Names
In C, a common style of variable declaration is
struct A { int x; }; typedef struct A A; A a;
In C++, classes, structs, unions, and enum names are automatically type names, so you can say:
U.K.R., 2008 OOP
struct A { int x; }; A a; enum E {ee}; E e;

15
Enumeration names
In C++, enumeration names can have values assigned to them, whereas in c they can not
//C style enum Color {Red, Green, Blue}; //C++ style enum Color {Red=2, Green=4, Blue=6}; Color background=Blue; enum Armstrong {first=153, second=370, third=371}; Armstrong one=first; Armstrong two=second;
U.K.R., 2008 OOP 16
Type Casting
In C++, type casting can be done in two different ways:

C style cast Function notation cast
int i, j; //C style float g = (float)i/2; //function notation float h = float(j)/2

U.K.R., 2008 OOP 17
Function prototype and default values In C, functions may have a prototype defined before implementation. In C++ it is compulsory In addition, arguments may have default values specified in the prototype which can be used when function is called without any argument
int square(float); void setBackground(Color c=Red);
U.K.R., 2008
OOP
18
Accessing variables
Global variable can be accessed using scope resolution operator while a local variable with the same name is already declared
int x=2; int main() { int x=5; cout << x; //local x cout << ::x; //global x }
U.K.R., 2008
OOP
19
Constant variable
Value once set can never be changed Example: main( ) {
const float PI = 22/7.0; int radius = 10; float area = PI*radius*radius; PI=6.2; //error }
Benefits:

Impossibility of accidental modification of data Increases readability

OOP 20
U.K.R., 2008
Const and #define

Incorrect Result:

Using #define
#define x 4-2 main( ) { int y = x*x; }

//incorrect, y = 4-2*4-2 = -6
Using const
const int x = 4-2; main( ) { int y = x*x; }

U.K.R., 2008
//correct, y = 2*2 = 4
OOP
21
Const and #define

Impossibility of creating variable conditionally
main( ) { int n; cin >> n; if(n > 0) { #define v n; cout << v*v; } else { #define v -n; cout << v*v; } } main( ) { int n; cin >> n; if( n > 0) { const int v = n;/*do rest thing*/ } else { const int v = -n;/*do other thing*/ } }
U.K.R., 2008 OOP 22
Constants and Pointers

int x = 4,y = 6; const int *p = &x; //variable pointed by p, is const, but pointer p is not *p = 8; //error p = &y; //ok int const *q = &x; //same as p
int * const r = &x; //pointer r is const, but variable pointed by r, is not *r = 10; //ok r = &y; //error const int * const s = &x; //pointer as well as variable pointed by s are const *s = 12; //error s = &y; //error
U.K.R., 2008 OOP 23
Application
void Strcpy(char * const dst, const char * const src) { char ch; src = &ch; //error src[0] = a; //error dst = &ch; //error }
U.K.R., 2008
OOP
24
Reference Variable
Creates an alternate name or alias for the variable Can be used to read or modify the original data stored in that variable Syntax of reference variable declaration:
Standard or user defined data type: char, short, int, float, etc. Reference operator C++ alias variable C++ original variable
DataType & ReferenceVariable = OriginalVariable

OrigialVariable
ReferenceVariable
U.K.R., 2008 OOP 25
Reference Variable
int count = 1; // declare integer variable count int &ref = count; // create ref as an alias for count count ++; // increment count normally ++ref; // increment count (using its alias)
1000
count
3 2 1
ref
Properties of a reference variable

Cannot exists independentlymust be initialized when they are created Cannot be manipulated independentlyexcept initialization operation, all the operation will be implied on original variable Can be viewed as a const pointer without dereferencing notation i. e. object/variable to which a reference refers cannot be changed.
U.K.R., 2008 OOP
int x = 2,y = 6; int * const ref = &x; //ok, x=4 *ref = 4; ref = &y; //error
26
Restrictions
You cannot reference of a reference variable You cannot create array of references You can not create pointer to a reference
U.K.R., 2008
OOP
27
Constants and References

Example:
int x = 4; const int &p = x; //read only alias for x p = 8; //error x = 8; //ok const int y = 6; int & q = y; const int &r = y; r = 10; y = 12;
U.K.R., 2008
//declaration syntax error //ok, y is const and r is a read only alias //error //error
OOP 28
Usage of References
Call by value:
main( ) { int x=4, y=5; //actual args change(x, y); }
x 4
y 5
void change(int a, int b) { int temp; temp = a; a = b; b = temp; }

U.K.R., 2008
//a,b formal params
a 5 4
temp
b 4 5
OOP
29
Usage of References
Call by address:
main( ) { int x=4, y=5; //actual args change(&x, &y); }
1000
x 5 4
1002
y 4 5
a
void change(int *a, int *b) { int temp; temp = *a; *a = *b; *b = temp; }
U.K.R., 2008 OOP
b
1006 1002
1004
1000 1008
temp
30
Usage of References
Call by reference:
main( ) { int x=4, y=5; //actual args change(x, y); }
x 5 4 a
y 4 5 b
void change(int &a, int &b) { int temp; temp = a; a = b; b = temp; }

U.K.R., 2008
//a,b formal args
temp
OOP
31
Usage of References
Avoid unnecessary copying
float deteminant(Matrix &m) { /*find determinant of matrix m here*/ }
Danger with references

Function invocation does not indicate that references are used. So passed argument may be changed unknowingly.
float deteminant(const Matrix &m) { /*find determinant of matrix m here*/ }
Possible solutionuse const
Possibility to write generic function

more that an one value can be retrieved from a a function
int f(int a, int b, int c, int &max, int &min); //take three integers and return sum, max and min void find(int ele, int *arr, bool &found, int &location); //find an element ele in array arr and if found return location
U.K.R., 2008 OOP 32
Return by References
int x = 2; int &f() { return x; }
int a = 4;
Function call
f() = a;
Result
x=4
U.K.R., 2008
OOP
33
Inline Functions
Eliminates the function-call overhead (caused by jumping in and out of functions having few statements) involved in the conventional functioning approach. Keyword inline before function Asks the compiler to copy code into program instead of making function call Compiler can ignore inline Good for small, often-used functions
U.K.R., 2008 OOP 34
Inline Functions
Syntax of inline function definition:
Specified using the same syntax as any other function except that they include the inline keyword in the function declaration.
Keyword, function qualifier
inline ReturnType FunctionName(Parameters) { // Body of a main function }
U.K.R., 2008
OOP
35
Inline Functions
Example
inline int sqr(int num) { return num * num; }
void main( ) { compiler // a = sqr(5); b = sqr(n); // } void main( ) { // a = 5*5; b = n*n; // }
inline int fact(int n { return (n < 2?1:n*fact(n-1)); }

void main( ) { compiler // a = fact(5); b = fact(4); cin >> n; c = fact(n); // }
U.K.R., 2008
void main( ) { // a = 120; b = 4*fact(3); cin >> n; c = fact(n); // }

OOP
//impossible to substitute
36
Inline Functions versus Macros

Inline functions: parsed by the compiler Macros : expanded by the preprocessor. E.g., #define max(x,y) ((x>y)?x: y) Limitation with macro: Macros are not functions and errors are not checked at compilation time until it is used.
U.K.R., 2008
OOP
37

Reasons why Inline functions are better than macros: Follow all the protocols of type safety enforced on
normal functions.
#define div(x,y) (x/y) void main() { cout << div(5,2); //wrong result 2 } inline float div(float a, float b) { return a/b ;} void main() { cout << div(5,2); //correct result 2.5 }
Expressions passed as arguments to inline functions are evaluated once. In some cases, expressions passed as arguments to macros are evaluated more than once.
U.K.R., 2008
OOP
38

# define SQUARE(num) num * num
Output
inline float square(float j) { return (j * j); } void main( ) { int p=3,q=3,r,s; r=SQUARE(++p); s=square(++q); cout<<r = << r << s = <<s; }
r =25 s =16
Macro SQUARE( ) is expanded as r = ++p * ++p In macro expansion p is incremented twice. inline function square( ) var q is incremented only once and is assigned to j then j * j is returned.
OOP 39
U.K.R., 2008
Function Overloading
Having more than one function with the same name differing in number, type and order of arguments It is a kind of Compile time Polymorphism
int abs(int); float abs(float); double abs(double); void print(int); void print(float); void print(int *, int); void print(Matrix m); void print(Student); //print an integer //print a float //print an array //print a matrix //print student data
U.K.R., 2008
OOP
40
Issues in Function Overloading
Functions differing in their return types only cannot be overloaded.
int pop(Stack &); float pop(Stack &); char pop(Stack &);
Overloaded function resolution

The compiler attempts to find an accurate function definition that matches in types and number of arguments and invokes the function. If no accurate match found, compiler tries out implicit conversions. e.g., char is converted to int, float to double etc. If no accurate match found
may lead to ambiguity as internal type
Ambiguity
conversions may take place. Consider: sum(int,int) and sum(float, float) The compiler will not be able to identify the function to be called
sum(1.1, 2.2);
U.K.R., 2008
//ambiguity:which sum? sum(int(1.1), int(1.1)) or sum(float(1.1), float(2.2)?

OOP 41
Default Values
void drawCircle(int x, int y, int radius); drawCircle(0,0,100); drawCircle(0,0,100, GREEN); //draw with WHITE color //error, 3 arguments needed
void drawCircle(int x, int y, int radius, int color=WHITE); drawCircle(0,0,100); drawCircle(0,0,100, GREEN); //color=WHITE //color=GREEN
Function arguments assume default values, when their values are neglected or insufficient number of values are furnished during function calls. Can be constants, global variables, or function calls
U.K.R., 2008 OOP 42
Default Values
int myFunction(int x = 1,int y = 2,int z = 3)

myFunction(3); //x = 3, y and z get defaults (rightmost) myFunction(3, 5); //x = 3, y = 5 and z gets default myFunction(3, 5, 7); //x = 3, y = 5 and z = 7
U.K.R., 2008
OOP
43
Default Values
Basic rules: When a default is provided, all parameters must be given defaults.
remaining
Default values must be of the correct type. Defaults can be placed on the function prototype or the function definition.
U.K.R., 2008
OOP
44

Program is composed of a collection of individual units, or objects, as opposed to a traditional view in which a program is a list of instructions to the computer
Object B
Data variable
Object A Object C
Member Function Data variable Member Function

U.K.R., 2008 OOP
Data variable Member Function

45
Object Oriented programming?

In an object oriented environment, software is a collection of discrete objects that encapsulate their data as well as the functionality to model real-world objects. Objects: Packaging data and functionality together into units within a running computer program; The basis of modularity and structure in an object-oriented computer program. Self contained and should be easily identifiable.
U.K.R., 2008
OOP
46
Benefits of Object Orientation

Modularity: Since the whole system is being modeled as classes and various methods are divided according to the respective functionalities in respective classes, modularity increases. Deferred Commitment: Since classes can be modified without modifying the actual code where the classes are being used, flexibility towards the commitment increases (Easier maintenance). The internal workings of an object can be redefined(easily) without changing other parts of the system. Reusability: Since defining classes through inheritance helps in reusability thus faster production.
U.K.R., 2008
OOP
47
Benefits of Object Orientation

Higher Quality: Since deriving classes from existing classes which are working successfully. Reduced cost: Because of reusability Increased Scalability: Easier to develop (integrate)large systems from well tested smaller systems.
U.K.R., 2008
OOP
48
Classes and Objects

Logical Abstraction A Class is a description of common properties of objects that belong to the class i.e., collection of objects with common characteristics. Create objects of various classes. These are the physical existence. For individual objects, are the data and functions replicated?
U.K.R., 2008
OOP
49
Terminology
Class - A software module that provides both procedural and data abstraction. It describes a set of similar objects, called its instances
Attribute - A simple data item present in all the instances of a class Data type - A name or label for a set of values and some operations which one can perform on that set of values. Association - A relationship between two classes that represents the existence of a set of links between objects of the two classes
window origin size open() close() move() display() Window Class
U.K.R., 2008
OOP
50
Classes
Polygon Abstract into vertices border area fillColor draw( ) erase( ) move( ) Class
Attributes
Polygon Objects
Operations
U.K.R., 2008
OOP
51
Classes
Attributes
Customer name address phone birthDate attributes Wall height::Float width::Float Thickness::Float isMovable::Boolean=false attributes
Customer Atrributes
Atrributes and their class
Student roll::Integer name::String address::String birthDate::Date attributes
PC hdd::Component ram::Memory Mouse::InputDevice keyboard::OutputDevice attributes

U.K.R., 2008 OOP

52
Classes
Operations
Rectangle area() grow() move isEmpty() Operations TeperatureSensor
operations
reset() setAlarm(t: Temperature) Value(): Temperature Operations
operations
Register endSale() enterItem(id: ItemId, qty: Integer) pay(cashTendered: Money) Operations
ATM
validate(crd: ATMCard, pin: Integer) withdraw(amount: Float) deposit(amount: Float) balance(): Float Oerations
U.K.R., 2008
OOP
53
Encapsulation
Bundling of the data and methods together
Transaction
Ensuring that users of an object cannot change the internal state of the object in unexpected ways; only the object's own internal methods are (generally) allowed to access its state. Each object exposes an interface that specifies how other objects may interact with it. Other objects will rely exclusively on the object's external interface to interact with it.
+execute() +rollback() #priority() -timestamp()
U.K.R., 2008
OOP
54
Inheritance
Ability to extend/subclass the behavior of existing class without changing the original class New class is called derived class/sub class Old class is called super class/base class Sub class inherits all the behavior of its super class New fields and methods can be added in the sub class
U.K.R., 2008
OOP
55
Inheritance
Shape origin move() resize() display() base/parent class Party
generalization
Rectangle tl: Point rb: Point area(): Float
Circle radius: Float center: Point area(): Float
Polygon points:List area(): Float display()
Customer
Supplier
Employer
Square leaf class

U.K.R., 2008
derived/child class
OOP
56
Polymorphism
Many(poly-) forms(-morph) Function overloading Operator overloading Inheritance Virtual function
U.K.R., 2008
OOP
57
Classes & Objects

p1 struct Point { int x, y; float distance(Point); /**/ }; void main( ) { Point p1, p2; p1.x=2; p1.y=4; p2.x=6; p2.y=8; float d = p1.distance(p2); } x 2 y 4 x 6 p2 y 8
Objects
Initialization of member variables
U.K.R., 2008
OOP
58
Classes & Objects

c1 struct Complex { double real, img; Complex add(Complex); /**/ }; void main( ) { Complex c1, c2; c1.real=1.5; c1.img=3.4; c2.real=5.6; c2.img=8.8; Complex c3 = c1.add(c2); } real img 1.5 3.4 c2 real img 5.6 8.8
Objects
U.K.R., 2008
OOP
59
Access Control
A member of a class can be private, public. (In inheritance, we use another access specify namely protected. So, a member of a class can be private, protected, or public.) If it is public, its name can be used by any function. If a member of a class is private, its name can be used only by member functions and friends of the class in which it is declared. If it is protected, its name can be used only by member functions and friends of the class in which it is declared and by member functions and friends of classes derived from this class.
U.K.R., 2008 OOP 60
Access Control
struct Complex { private : double real, img; public : void set(double r, double i) { real = r; img = i; } Complex add(Complex c) { Complex temp; temp.set(real+c.real, img+c.img); //real and img are //accessible from member function } /**/ }; void main( ) { Complex c1, c2; c1.real=1.5; c1.img=3.4; c1.set(1.5, 3.4); c2.set(5.6, 8.8); double d = c1.add(c2); }
U.K.R., 2008 OOP 61
//error, real and img are private; //not accessible from outside //ok, access through public member function //ok, access through public member function
Inline Member Functions

If a member function is implemented outside the class braces, it is not inlined by default, but it can be defined as inline using the inline keyword.
class Point { public: int x, y; void setx(int); void sety(int yy) {y=yy;} float distance(Point); /**/ }; void Point::setx(int xx) {x=xx;} inline float Point::distance(Point p) { return sqrt((x-p.x)*(x-p.x)+(y-p.y)*(y-p.y); }
U.K.R., 2008 OOP
Member function prototype declaration
Member function defined insideinlined by default Member function defined outsidenot inlined Member function defined outside inlined explicitly
62
this pointer
class Point { public: int x, y; void setx(int xx) {x=xx;} /**/ }; void main( ) { Point p1, p2; p1.setx(2); p2.setx(6); } x, y p1 x, y p2
void setx(int xx) { x = xx; }
void setx(int xx, Point *this) { this->x = xx; }
setx(2, &p1); setx(6, &p2);

U.K.R., 2008 OOP
void setx(int x) { this->x = x; }

63
Constructors and Destructors

class Point { private: int x, y; public: void setx(int x) {this->x=x;} void sety(int yy) {y=yy;} float distance(Point); /**/ }; void main( ) { Point p1, p2; p1.setx(2); p1.sety(4); p2.setx(6); p2.sety(8); float d = p1.distance(p2); }
U.K.R., 2008 OOP
64
Solution is constructor
class Point { public: int x, y;
Constructor declared Constructor defined Object created and initialized by constructor Inside Point( ) Inside main( ) x= 2 y= 4
Point( );
};
Point::Point(void)
{ cout<<" Inside Point( )\n"; x=2;y=4; // if not initialized garbage } void main( ) { Point p; //Point p = Point(); cout<<"Inside main( )\n"; cout<<"x= " << p.x<<"y= "<<p.y; }
U.K.R., 2008 OOP
Object p x= 2 y= 4
65
Constructors contd.,
Constructors are special member functions with the same name as the class. A constructor on each object is called when it is created They are commonly used to initialize the member variables. Constructors do not return values. They have no return type specified
U.K.R., 2008
OOP
66
Constructors contd.,
A constructor is called whenever an object is defined or dynamically allocated using the new operator If no constructor is explicitly written then a default is created (not in the case of const and reference data members). The purpose of a copy constructor is to initialize a new object of a given class by copying an existing object of that class.
U.K.R., 2008
OOP
67
Dynamic Memory Allocation

int *x; x = new int[100]; float *f; f = new float[10]; char *str; str = new char[4]; str[0] = C; str[1] = +; str[2] = +; str[3] = \0; class Point { int x, y; }; Point *ptr; ptr = new Point[5]; for(int i=0;i<5;i++) { Point p; ptr[i] = &p; }
delete(x); delete(f); delete(str); delete(ptr);
U.K.R., 2008
OOP
68
Constructors with arguments

Parameters can be passed to the constructors
class Point { public: int x, y; Point(int i, int j); }; Point::Point(int i, int j) { x=i;y=j; } void main( ) { Point p1(10, 20); Point p2 = Point(30, 40); Point p3 = p2; }
U.K.R., 2008 OOP
Parameterized Constructor
Constructor called implicitly
Object p1 Object p2
x= 10 y= 20 x= 30 y= 40
69
Overloading Constructors
Overloading Constructors - Multiple constructors declared in a class All constructors have different number of arguments Depending on the number of arguments, compiler executes corresponding constructor
Point( ) {x=10;y=20;}; Point(int i, int j) {x=i;y=j;};
No arguments: Point p;
Two arguments: Point p1(2,4) Copy constructor: Point p2=p1

70
Point(const Point & i) {x=i.x;y=i.y;};

U.K.R., 2008 OOP
Constructors with default arguments

Constructors can be defined with default arguments
class Point { public: int x, y; Point(int i, int j=10) { x=i;y=j; } }; void main() { Point p1(1); Point p2(8, 9); } Object p1 Object p2 x= 1 y= 10 x= 8 y= 9 Default value for j=10 (Used by the object p1)
U.K.R., 2008
OOP
71
Copy Constructors
Constructors can accept arguments of any data type including user defined data types and an object of its own class C++ calls a copy constructor to make a copy of an object. If there is no copy constructor defined for the class, C++ uses the default copy constructor which copies each field, ie, makes a shallow copy. Point p1(10); //Object created and initialized Point p2(p1); //Copy constructor Point p3=p1; //Copy constructor Point p4; p4=p1; //Member wise copy
U.K.R., 2008 OOP 72
Copy Constructors contd.,

class aClass { public: int x; aClass(){ } aClass(int i) {x=i;} aClass(aClass &j) {x=j.x;} }; void main() { aClass o1(10); aClass o2(o1); aClass o3=o1; aClass o4; o4=o1; }
Objects
o1 x=10
o2 x=10
OOP
o3 x=10
o4 x=10
73
U.K.R., 2008
Importance of Copy Constructors

class Stack { private : int *a, size, top; public : Stack(int sz):top(-1) { top = -1; a = new int[size=sz]; } void push(int item) { a[++top]=item; } int pop() { return a[top--]; } };
Solution
class Stack { public : Stack(const Stack &s) { top=s.top; int *temp=a; a=new int[size=s.size]; for(int i=0;i<size;i++) a[i]=s.a[i]; delete(temp) } }; size s1 a
3 6 9 4
Stack s1(4), s2=s1;

s2
U.K.R., 2008 OOP
top size a
After s2=s1
74
top
Importance of Copy Constructors

class String { int length; char *buf; public: String(int size) { buf = new char[(length = size)+1]; } };
Solution
class String { String(const String &str) { length = str.length; buf = new char[length+1]; strcpy(buf, str.buf); } };
String s1(4), s2=s1;

s1
buf length buf s2 length
C + + 4 3 6 9 \0
After s2=s1
75
U.K.R., 2008
OOP
Destructors
When an object goes out of scope then it is automatically destructed. It performs clean up of the object ( using delete in the case of allocating memory inside the object using new ) Destructors have no arguments and thus cannot be overloaded
U.K.R., 2008
OOP
76
Destructors contd.,
Declaration Same name as class Preceded with tilde (~)
~Point( ) { }
U.K.R., 2008
OOP
77
Static Members
class Point { int x, y; /**/ }; Point p1, p2;
x, y p1 x, y p2
For each object, an instance of each non-static data member is created
U.K.R., 2008
OOP
78
Static Members
Static Data Members:
Static members are members that are single shared member common to all the objects created for a particular class. Memory allocation is done only once and not every time an object is created.
Object A
Object B
Static variable
Object C
U.K.R., 2008 OOP 79
Static Members contd.

Only one copy of static data member will exist irrespective of the number of objects created Static functions can access only static variables Efficient when single copy of data is enough May seem like global variables, but have class scope Only accessible to objects of same class
U.K.R., 2008
OOP
80
Static Members contd.,

Static Member Example
class SavingsAccount { private: int currentBal; public : static int RateofInt; SavingsAccount(int b) {currentBal=b;} }; int SavingsAccount::RateofInt=10; SavingsAccount myAccount(0), yourAccount(1);
Shared by all objects Object yourAccount
Object myAccount
U.K.R., 2008
currentBal=0
OOP
currentBal=1
81

Static Member Example
class Car { private: const int serialNo; public : static int nextSerial; Car():serialNo(nextSerial++) {} }; int Car::nextSerial=10; Car aCar, anotherCar;
Shared by all objects Object anotherCar
Object aCar
U.K.R., 2008
serialNo=10
OOP
serialNo=11
82
Static Member function

Static Member function example
class Car { public : static int nextSerial; static void reset() { nextSerial = 0; } };
U.K.R., 2008
OOP
83

Static Data Members:
class SavingsAccount Only one copy should { be available as all private: objects should have char name[30]; same Interest rate float total; float CurrentRate; public: To make CurrentTate accessible to all objects SavingsAccount(); void EarnInterest() { Declare CurrentRate as total + = CurrentRate * total; static float CurrentRate; } }
U.K.R., 2008 OOP 84
Constant Functions
Declaring a member function with the const keyword specifies that the function is a "read-only" function that does not modify the object for which it is called. If a const function attempt to change the data, the compiler will generate an error message. Illegal to declare a const member function that modifies a data member
class Point { int x,y; public : void setx(int xx) {x=xx;;} int getx( ) const {return x;} };
U.K.R., 2008 OOP
const(read only) member function, Any attempt to modify the member variables is an error
85
Constant Functions
const member functions can be invoked on const as well as non-const objects but non-const member functions can be invoked on non-const objects only
class Point { int x,y; public : void setx(int xx) {x=xx;;} int getx( ) const {return x;} }; const Point cp; Point p; int x = cp.getx(); //OK cp.setx(2); //Error x = p.setx(2); //OK p.getx(); //OK
U.K.R., 2008
OOP
86
Mutable data members
class Point { mutable int x; public : void setx(int xx) {x=xx;} int getx( ) const { x++; //OK } };
U.K.R., 2008 OOP 87
Mutable data members

class Point { mutable int cnt; public : void setx(int xx) { ... count(); } int count( ) const { return cnt++; //OK } };
U.K.R., 2008 OOP 88
Friend Functions and Classes

A friend of a class can access even its private members. Useful when one class wants to see the private member variables of another class, even though those variables should not be made public Friend can be
A non-member function A member function of a class An entire class
U.K.R., 2008
OOP
89
Non-member as a friend example

void f() { /**/ } class X { friend void f(); };
A non-member function can be a friend of any number of classes

U.K.R., 2008 OOP 90
Non-member as a friend example

class Humidity; class Temperature { public: friend void PrintWeather(Temperature &t, Humidity &h); }; class Humidity { public: friend void PrintWeather(Temperature &t, Humidity &h); }; void PrintWeather(Temperature &t, Humidity &h) { //print both temperature and humidity }
U.K.R., 2008 OOP 91
Member as a friend example

class Y { friend void X::f(); };
class X { void f(); };
A member function can be a friend of any number of classes

U.K.R., 2008 OOP 92
Member as a friend example

class Node { private: int data, key; // ... friend void BinaryTree::find(int); // BinaryTree::key() can now access data directly }; class BinaryTree { private: Node *root; int find(int key); }; int BinaryTree::find(int key) { // check root for NULL... if(root->key == key) { // no need to go through an accessor function return root->data; } // perform rest of find }
OOP 93
U.K.R., 2008
Class as a friend example

class X { void f(); }; class Y { friend class X; };
A class can be a friend of any number of classes
U.K.R., 2008
OOP
94
Operator overloading
Example: the + (plus) operator in C++ behaves differently depending on the operands: 4+5 - integer addition 3.14 + 2.0 - floating point addition
Object + Oriented" - string concatenation
In C++, this is called operator overloading To overload means give it a meaning for user defined data type. Operator overloading, a way of achieving static polymorphism, which provides simply another way to make a function call for you
U.K.R., 2008 OOP 95
Operator Functions
Complex c1(2, 4), c2(3, 5), c3, c4; c3 = c1 + c2; C3=c1.operator+(c2); c4 = -c1; c4 = c1+c2*c3; Array a1(10), a2(10), a3, a4; a3 = a1+a2; a4 = -a1; if(a1 < a2) { // }
Matrix m1(2, 4), m2(4, 3), m3; m3 = m1 + m2; Matrix m4 = m1*m2;
String s1(C++), s2(Java); String s3 = s1 + s2;
Operators on built-in data types can not be overloaded
U.K.R., 2008
OOP
96
Operator Overloading
Operators that can be overloaded + ~ /= <<= -new[] ! %= == ->* delete[] * = ^= != -> / < &= <= . % > |= >= [] ^ += << && () & -= >> || new | *= >>= ++ delete
Operators that can not be overloaded
U.K.R., 2008
.*
OOP
?:
sizeof
97
Operator Functions
Operators can be interpreted as functions in C++ The number of arguments in the overloaded operators argument list depends on two factors
Whether its a unary operator or binary operator Whether the operator is defined as a global function or a member function
U.K.R., 2008
OOP
98
Operator Functions
Unary operator @ on object o will be interpreted as operator@(o) or o.operator@() Binary operator @ on object o1 and o2 will be interpreted as operator@(o1, o2) or o1.operator@(o2) Complex c1(2,4), c2(3,5),c3,c4; c3 = c1+c2; //will be interpreted as c3 = operator+(c1,c2); //OR c3 = c1.operator(c2); c4 = -c1; //will be interpreted as operator-(c1); OR c1.operator-()
U.K.R., 2008 OOP 99
Syntax of Operator overloading as non-member
Keyword Operator to be overloaded
ReturnType operator OperatorSymbol (argument list) { \\ Function body }
Number of arguments for non-member operator function for Unary operator 1 Binary operator 2
U.K.R., 2008 OOP 100
Syntax of Operator overloading Class Member Number of arguments in a member function for
Unary operator 0 Binary operator 1 Operator to be overloaded
ReturnType classname :: operator OperatorSymbol (argument list) { \\ Function body }

U.K.R., 2008 OOP 101
Unary Operators Overloading

To declare a unary operator function as a nonstatic member
return-type operator op()

To declare a unary operator function as a global function
ret-type operator op(arg )
U.K.R., 2008
OOP
102
Unary (minus) operator overloading

Using member function
class Complex { private: int real, img; public: /**/ Complex operator -() { Complex temp; temp.real = -real; temp.img = -img return temp; } };
Usage: Complex c1(2,4), c2; c2 = -c1; //c1.operator -() is called
U.K.R., 2008
OOP
103
Unary (minus) operator overloading

class Array { private: int *buf, length; public: /**/ Array operator -() { Array temp = *this; for(int i=0;i<temp.length;i++) temp.buf[i] = -temp.buf[i]; return temp; } };
Usage: Array a1(10), a2; a2 = -a1; //a1.operator -() is called
U.K.R., 2008
OOP
104
Pre-increment operator overloading

class Index { private: int x; public: /**/ // Declare prefix increment operators. Index operator++(); }; Usage: Index in, out; ++in; //in.operator ++() is called out = ++in;
U.K.R., 2008 OOP 105
Post-increment operator overloading

class Index { private: int x; public: /**/ // Declare postfix increment operators. Index operator++(int); }; Usage: Index in, out; out++; //out.operator ++(int) is called in = out++; //out.operator ++(int);
U.K.R., 2008 OOP 106
Implementation?
// Define prefix increment operator. Index Index ::operator++() { x++; return *this; } // Define postfix increment operator. Point Point::operator++(int) { Point temp = *this; ++*this; //or ++x; return temp; }
U.K.R., 2008 OOP 107

Using non-member function
class Complex { private: int real, img; public: /**/ friend Complex operator -(Complex); }; Complex operator -(const Complex &c) { Complex temp; temp.real = -c.real; temp.img = -c.img return temp; }
U.K.R., 2008 OOP 108

class Array { private: int *buf, length; public: /**/ friend Array operator -(Array); }; Array operator -(const Array &a) { Array temp = a; for(int i=0;i<temp.length;i++) temp.buf[i] = -temp.buf[i]; return temp; }
U.K.R., 2008 OOP 109

friend Index operator++(Index & ) // Prefix increment friend Index operator++(Index &, int ) // Postfix increment
//using friend function friend Index operator++(Index & i) { i.x++; //i.x is private, but friend function can access it return i; } //withou using friend function Index operator++(Index & i) { i.set(i.val()+1); //increment using reader and writer function return i; }
U.K.R., 2008 OOP 110
Binary Operator Overloading

To declare a binary operator function as a nonstatic member, you must declare it in the form:
ret-type operator op( arg )

To declare a binary operator function as a nonmember function, you must declare it in the form:
ret-type operator op( arg1, arg2 )
U.K.R., 2008
OOP
111
Binary + Operator Overloading

class Complex { int r, i; public: Complex operator + (const Complex &); Complex operator * (const Complex &); }; class Complex { public: int r, i; /**/ Complex operator + (const Complex & c) { Complex temp; temp.r = r+c.r; temp.i = i+c.i; return temp; } };
OOP 112
int main () { Complex c1(2,3), c2(4,5), c3; c3=c1+c2; c1=c1+c2*c3; c3=c1*c3; }
U.K.R., 2008
Binary += Operator Overloading

Minimize number of function directly manipulate objects
class Complex { int r, i; public: Complex operator + (const Complex &); Complex operator += (const Complex &); };
int f(Complex x, Complex y, Complex z) { Complex r1 = x+y+z; //r1 = x.operator+(y.operator+(z)); Complex r2 = x; //r2 = x; r2 += y; //r2.operator+=(y); r2 += z; r2.operator+=(z); }
Computations of r1 and r2 are equivalent

U.K.R., 2008 OOP 113
Binary += Operator Overloading

Definition of += is simpler and efficient
Complex Complex::operator += (const Complex & c) { r += c.r; i += c.i; return *this; } Complex Complex::operator + (const Complex & c) { Complex temp = *this; return temp += c; }
Three objects are involved in a + operation Two objects are involved in a += operation
U.K.R., 2008 OOP 114
Mixed-Mode Arithmetic
To Handle Complex c1 = 2 + c2 we need to define operators of different types
class Complex { int r, i; public: Complex operator + (const Complex &); Complex operator += (const Complex &); }; Complex operator + (double, const Complex &);
void f (Complex x, Complex y) { Complex c1 = x+y; //c1 = x.operator+(y) Complex c2 = 2+x; //c2 = operator(2, x) }
U.K.R., 2008 OOP 115
Mixed-Mode Arithmetic
Two ways to Handle Complex c1 = c2+2
class Complex { public: Complex(int); Complex operator + (const Complex &); }; void f (Complex x) { Complex y = x+2; //y = x.operator+(Complex(2)) } class Complex { public: //no one argument constructor }; Complex operator + (const Complex & , double); void f (Complex x) { Complex y = x+2; //y = operator+(x, 2) }
U.K.R., 2008 OOP 116
Ambiguity
Ambiguity may occur of one argument constructor and operator functions both are defined
class Complex { public: Complex(int); Complex operator + (const Complex &); }; Complex operator + (const Complex & , double); void f (Complex x) { Complex y = x+2; //ambiguity, y = x.operator+(Complex(2)) or y = operator+(x, 2)? }
U.K.R., 2008
OOP
117
Explicit Constructor
Implicit conversion can be prevented by declaring constructor explicit
class Complex { public: explicit Complex(int); Complex operator + (const Complex &); }; void f (Complex x) { Complex y = x+2; // error Complex z = x+Complex(2); // ok }
U.K.R., 2008
OOP
118
Overloading = operator
class Stack { Solution private : int *a, size, top; class Stack { public : public : Stack(int sz) { Stack & operator = (const Stack &s) { top = -1; top = s.top; a = new int[size = sz]; delete a; } a = new int[size = s.size]; void push(int item) { for(int I = 0; I < size; i++) a[++top] = item; a[i] = s.a[i]; } return *this; int pop() { } return a[top--]; }; } };
Stack s1(4), s2(5); s2=s1;
s1 s2
a a
3 6 9 4
s1 s2
a a
3 6 9 4
Before s2=s1
U.K.R., 2008 OOP
After s2=s1
119
Overloading = operator
class String { private: char *buf; public: int length; String & operator=(const String &); }; String & String::operator=(const String & s) { if(this == &s) return *this; delete buf; length = s.length; buf = new char[length + 1]; strcpy(buf, s.buf); return *this; }
U.K.R., 2008
OOP
120
Overloading assignment operator

Assignment operator (=) is a binary operator. Its declaration is identical to any other binary operator, Exceptions: It must be a non-static member function. No operator = can be declared as a non-member function. It is not inherited by derived classes. A default operator= function can be generated by the compiler for class types if none exists (bitwise shallow copy) User defined operator= function performs member wise deep copy.
U.K.R., 2008
OOP
121
Predefined meaning of operators

A default operator= function can be generated by the compiler for class types if none exists (bitwise shallow copy) Declare it private to make them inaccessible
class X { private : X operator=(const X&); /**/ }; void f(X, a, X b) { a = b; //error: operator= private }
U.K.R., 2008
OOP
122
Overloading assignment operator
class Point { public: Point &operator=( Point & ); // Right side is the argument. ... }; // Define assignment operator. Point &Point::operator=( Point &pt) { x = pt. x; y = pt. y; return *this; // Assignment operator returns left side. }
U.K.R., 2008 OOP 123
[ ] operator Overloading
Array a(10); a[4] = 6; int x = a[4]; String s(C++); s[0] = J; Table t(4, 5); int x = t[2][3]; t[0][0] = 5;
Database db; db["user1"]= "abc"; db["user2"]= "xyz"; db["user3"]= "pqr"; if(db[user1] == passwdGiven) { // allow to login } else { // dont allow to login }
U.K.R., 2008
OOP
124
[ ] operator Overloading example

class Array { private: int *buf; public: int length; Array(); Array(int); int &operator[] (const int &); }; int &Array::operator[] (const int &index) { return buf[index]; }
Array a(10); a[4] = 6; //a.operator[](4) = 6; int x = a[4]; //x = a.operator[](4);
U.K.R., 2008
OOP
125

class String { private: char *buf; public: int length; String(); String(char *); char &operator[] (const int &); }; char &String::operator[] (const int &index) { return buf[index]; }
String s(C++); s[0] = J; //s.operator[](0) = J; char ch = s[1]; //ch = s.operator[](1);
U.K.R., 2008
OOP
126

class Table { private: Array * buf; public: int row, col; Table(); Table(int, int); Array & operator[] (const int &); }; Array & Table::operator[](const int &index) { return buf[index]; }
Table t(4, 5); int x = t[2][3]; t[0][0] = 5;
U.K.R., 2008
OOP
127

class Pair { public: String name, value; Pair(const String &n, const String &v); Pair(); }; class Database { private: Pair *list; public: int length; Database(); Database(const int&); String& operator[](const String&); };
U.K.R., 2008
OOP
128

String& Database::operator[](const String& s) { int index = -1; for(int i=0;i<length;i++) if(s == list[i].name) { index = i; break; } if(index != -1) return list[index].value; else { Pair *p = list; list = new Pair[++length]; for(int i=0;i<length-1;i++) list[i] = p[i]; list[length-1].name = s; return list[length-1].value; } }
U.K.R., 2008 OOP
Database db; db["user1"]= "abc"; db["user2"]= "xyz"; db["user3"]= "pqr"; if(db.[user] == passwdGiven) { // allow to login } else { // dont allow to login }
129
Friends and Members

Better choice? Motivation
Minimize the number of functions accessing representation of a class directly Only one choice for constructors, destructors, virtual functions
Function that requires direct access should be a member unless there is a specific reason for it to be a non-member
U.K.R., 2008
OOP
130
Friends and Members

class X { // X(int); int m1(); int m2() const; friend void f1(X&); friend void f2(const X&); friend void f3(X); }; void h() { f1(99); //error: f1(X(99)) not tried f2(99); //ok: f2(X(99)); f3(99); //ok: f3(X(99)); } void g() { 99.m1(); 99.m2(); } //error: X(99).m1() not tried //error: X(99).m2() not tried
Operation modifying state should be a member or a global function taking non-const reference =, +=, ++ are naturally defined as member If implicit conversion is desired, function must be non-member taking const reference or non reference
U.K.R., 2008 OOP 131
Friends and Members

If no type conversion is desired, there is no compelling reason to choose a member or non-member Choices depends on function call syntax inv(m) or m.inv()? If inv() really inverts m, choose member otherwise nonmember Member call syntax makes it clear to the user that object may be modified; a reference argument is far less obvious Members are shorter than non-member
U.K.R., 2008
OOP
132
Operators for large objects

class Matrix { double m[4][4]; Matrix(int); friend Matrix operator+(const Matrix&, const Matrix&); }; Matrix operator+(const Matrix& m1, const Matrix& m2) { Matrix temp; for(int i=0;i<4;i++) for(int j=0;j<4;j++) temp.m[i][j] = m1.m[i][j]+m2[i]j]; return temp; }
U.K.R., 2008
OOP
133
Operators for large objects

const int MAX 10; Matrix & get_matrix() { static int index = 0; static Matrix buf[MAX]; return buf[index++]; } Matrix operator+(const Matrix& m1, const Matrix& m2) { Matrix& temp = get_matrix(); for(int i=0;i<4;i++) for(int j=0;j<4;j++) temp.m[i][j] = m1.m[i][j]+m2[i]j]; return temp; }
U.K.R., 2008
OOP
134
Overloading << operator

#include <iostream.h> int main() { char *str = C++; int x = 2; cout << str; cout << x; return 1; }
//cout.operator<<(str); cout.operator<<(x);
Consider the simplified version of string I/O from standard library

class ostream { ostream& operator<<(const char*); ostream& operator<<(int); /**/ }; extern ostream cout;
U.K.R., 2008 OOP 135
Overloading << operator

#include <iostream.h> int main() { Array a(10), b(3), c(5); String str(C++); Table matrix(3, 4); cout << a; //operator<<(cout, a); cout << str; //operator<<(cout, str); cout << matrix; //operator<<(cout, matrix); cout << b << c; //operator << (operator << (cout, b), c) return 1; }
U.K.R., 2008
OOP
136
<< operator implementation

class Array { /**/ friend ostream& operator<<(ostream& os, const Array&); }; ostream& operator<<(ostream& os, const Array&); ostream& operator<<(ostream& os, const Array& a) { for(int i=0;i<a.length;i++) os << a[i] << ' '; return os; }
U.K.R., 2008
OOP
137

class String { /**/ friend ostream& operator<<(ostream& os, const String&); }; ostream& operator<<(ostream& os, const String&);
ostream& operator<<(ostream& os, const String& s) { os << s.buf; return os; }
U.K.R., 2008
OOP
138

class Table { /**/ friend ostream& operator<<(ostream& os, const Table&); }; ostream& operator<<(ostream& os, const Table&); ostream& operator<<(ostream& os, const Table& t) { for(int i=0;i<t.row;i++) { os << "\n"; os << t[i]; } return os; }
U.K.R., 2008
OOP
139
Overloading >> operator

#include <iostream.h> int main() { char str[10]; int x ; cin >> str; cin >> x; return 1; }
//cin.operator>>(str); cin.operator>>(x);
Consider the simplified version of string I/O from standard library

class istream { istream& operator>>(const char*); istream& operator>>(int); /**/ }; extern istream cin;
U.K.R., 2008 OOP 140
Overloading >> operator

#include <iostream.h> int main() { Array a , b, c; String str; Table matrix; cin >> a; //operator>>(cin, a); cin >> str; //operator>>(cin, str); cin >> matrix; //operator>>(cin, matrix); cin >> b << c; //operator >> (operator >> (cin, b), c); return 1; }
U.K.R., 2008
OOP
141
Conversion operator
One argument constructor is a conversion operator It can convert user define/built-in data type to user defined data type
class String { public: String(char *); }; Class Table { /**/ }; class Matrix { public: Matrix(Table); };
//conversion from char * to String
//conversion from Table to Matrix
Convenient but has implication that can be undesirable

U.K.R., 2008 OOP 142
Conversion operator
It can not specify
User defined to built in conversion Conversion from a new class to old class without modifying the old class
User defined conversions are considered when necessary

class String { char *buf; public: String(char *); operator char*(); }; void f() { String str(C++); char *s = str; str = Java; }
U.K.R., 2008
//conversion to char *
//s = char*(str); //in = String(2);

OOP 143
Conversion operator
class Index { int i; public: Index(int); operator int(); operator Integer(); }; void f () { Index in(4), out(10); int x = in; int y = in + out in = 2; Integer i; i = in; }
U.K.R., 2008
//conversion to int //conversion to Integer
//x = int(in), x = 4 //y = int(in) + int(out), y = 14 //in = Index(2) //i = Integer(in);

OOP 144
Conversion operator
class Array { int *buf; public: Array(int); operator int*(); }; void f () { Array a(10); int *arr = a; }
//conversion to int*
//arr = int*(a)
U.K.R., 2008
OOP
145
Conversion operator Implementation

Index::operator int() { return i; } Index::operator Integer() { return Integer(i); } String::operator char*() { char *str = new char[length+1]; strcpy(str, buf); return str; }
Array::operator int*() { int *temp = new int[length]; for(int i = 0; i < length; i++) temp[i] = buf[i]; return temp; }
U.K.R., 2008 OOP 146
Ambiguity
An assignment of a value of type V to an object X is legal if
V is X Or there is an unique conversion from V to X
class Index { /**/ Index(int); // int to Index conversion }; class Integer { /**/ Integer(int); // int to Integer conversion }; void f(Index); Void f(Integer); void h() { f(2); //error, ambiguous, f(Integer(2)) or f(Index(2)) ? }
U.K.R., 2008 OOP 147
Ambiguity
If both user-defined conversions and user-defined operators are defined, it possible to get ambiguity
class Integer { /**/ Integer(int); // int to Integer conversion operator int(); // Integer to int conversion Integer operator+(Integer, Integer); }; void f(int x, Integer y) { x+y; //error, ambiguous: operator+(Integer(x), y) or x+int(y)? }
U.K.R., 2008
OOP
148
Multilevel conversion
Only one level of user defined implicit conversion is legal If multiple implicit conversions are required to construct a value, it must be handled explicitly
class Index { /**/ Index(int); // int to Index conversion }; Class Integer { /**/ Integer(Index); // Index to Integer conversion }; void f(Integer); void h(int i) { f(i); //error, f(Integer(Index(i))) not tried f(Integer(i)); //ok, f(Integer(Index(i))) f(Index(i)); //ok, f(Integer(Index(i))) }
U.K.R., 2008 OOP 149
Other issues
Return type is not used as overload resolution
class Integer { public: Integer(double); }; Integer operator +(Integer, Integer); vid f(doube d1, double d2) { Integer q1 = d1 + d2; //double precison add Integer q2 = Integer(d1) + d2; //force Integer add }
Programmer should specify the precision to be used
U.K.R., 2008
OOP
150
Other issues
If both sides of an assignment or assignment have been determined, both types are used to resolve resolution
class Real { public: operator double(); operator int(); }; void f(Real r) { double d = r; // d = r.double(); int i = r; // i = r.int(); d = r; // d = r.double(); i = r; // i = r.int() }
U.K.R., 2008
OOP
151
Things to remember
It is not a good idea to define a conversion operator without significant reason When used in excess, they lead to ambiguity Rely on either user-defines conversions or user-defined operators, but not both
U.K.R., 2008
OOP
152
Overloading new operator

int *x = new int; float *f = new float; double *d = new double; // *x = ? // *f = ? // *d = ?
Standard implementations of new and new[] do not initialize memory returned Default behavior can be overridden by redefining new operator
void * operator new (size_t sz); int *x = new int; float *f = new float; double *d = new double;
U.K.R., 2008
// operator new(sizeof(int)); // operator new(sizeof(float)); // operator new(sizeof(double));

OOP 153
new operator implementation

void * operator new (size_t sz) { void * temp = malloc(sz); for(int i = 0; i < sz; i++) ((char *)temp)[i] = 0; return temp; }
U.K.R., 2008
OOP
154
new operator for class

Point *p = new Point;
Calls operator new(sizeof(Point)) or Point::operator new(sizeof(Point)) If new operator call is successful (memory allocation is successful), it calls Points default constructor Specialized allocator/deallocator for a class can be provided
class Point { public: void *operator new(size_t); };
operator new is implicitly static, consequenctly it does not have this pointer
U.K.R., 2008 OOP 155
new operator for class

Implementation
void * Point::operator new (size_t sz) { void * temp = malloc(sz); if(temp == NULL) { //try to find some free memory void * temp = malloc(sz); if(temp == NULL) { cout << "Memory exhausted\n"; return NULL; } } return temp; }
U.K.R., 2008
OOP
156
Overloading new[ ] operator

Default behavior can be overridden by redefining new operator
int *x = new int[2]; float *f = new float[4]; double *d = new double[10]; // x[0], x[1] = ? // f[2] = ? // d[4] = ?
void * operator new[] (size_t sz); int *x = new int[2]; float *f = new float[4]; double *d = new double[10]; // operator new[](sizeof(int)); // operator new[](sizeof(float)); // operator new[](sizeof(double));
U.K.R., 2008
OOP
157
new[ ] operator implementation

void * operator new[ ] (size_t sz) { void * temp = malloc(sz); for(int i = 0; i < sz; i++) ((char *)temp)[i] = 0; return temp; }
U.K.R., 2008
OOP
158
Overloading delete operator

Deallocates memory allocated by new
void operator delete (void *); void operator delete (void *p) { if(p) { // deallocate memory allocated by new; } }
U.K.R., 2008
OOP
159
Overloading () operator
One popular use of () operator is as subscripting operator for multidimensional arrays
class Table { int ** buf; public: int& operator() (const int &, const int &); }; Table matrix(10, 10); int x = matrix(4, 5); matrix(2, 3) = 8;
Implementation
int& Table::operator() (const int &i, const int &j) { return buf[i][j]; }
U.K.R., 2008
OOP
160
Overloading () operator
Function Objects
Objects used as a function class Point { int x, y; public: void operator() (const int &, const int &); }; void operator() (const int &xx, const int &yy) { x = xx; y = yy; } Point p(3, 4); p(4, 5);
U.K.R., 2008
//object used as a function

OOP 161
Overloading
operator
Dereference operator can be used as unary postfix operator Given a class class Ptr { public: X* operator->(); }; Objects of Ptr can be used to access members of class X in a very similar manner to the way pointers are used void f(Ptr p) { p->m = 2; }
// (p.operator->())->m = 2;
U.K.R., 2008
OOP
162
Overloading
Example class Point { private: int x, y; public: Point(); Point(int, int); int getx(); void setx(int); };
operator
class PPtr { Point *ptr; public: PPtr(); PPtr(Point &); Point* operator->(); };
p1(5,6); PPtr pp(p1); cout << pp->getx();

U.K.R., 2008 OOP 163
Overloading
operator
For ordinary pointers, use of -> is synonymous with some uses of unary * and []. Given Y *p it holds that p->m == (*p).m == p[0].m Such gurantee is not provided for user-defined operators class APtr { Array *arr; public: APtr(); APtr(Array &); Array* operator->(); Array& operator[](int); Array& operator*(); Array& operator++(); };
U.K.R., 2008 OOP
Array *a = new Array[4]; APtr ptr(*a); for(i = 0;i<4;i++) cout << ptr[i]; ptr++; ptr->length; cout << *ptr;
164
Bitwise operator overloading

class Bit { char b:1; public: Bit(); Bit(int); Bit operator|(Bit); Bit operator&(Bit); Bit operator^(Bit); Bit& operator!(); }; Bit Bit::operator|(Bit bit) { Bit temp; temp.b = b|bit.b; return temp; }
Bit b1(1), b2(0), b3; b3 = b1 | b2; b3 = b1 & b2; b3 = b1 ^ b2; b3 = !b1;
U.K.R., 2008
OOP
165
4. Inheritance
By using the concepts of inheritance, it is possible to create a new class from an existing one and add new features to it. Inheritance provides a mechanism for class level Reusability. Semantically, relationship. inheritance denotes an is-a
U.K.R., 2008
OOP
166
Inheritance
Person Name Height Age
Student Reg.No. Course Marks
Teaching Staff Edn.Qual. Designation Specialization
Person is a generalization of Student. Student is a specialization of Person.

U.K.R., 2008 OOP 167
Inheritance
Inheritance is the relationship between a class and one or more refined version of it. The class being refined is called the superclass or base class and each refined version is called a subclass or derived class. Attributes and operations common to a group of subclasses are attached to the superclass and shared by each subclass. Each subclass is said to inherit the features of its superclass.
U.K.R., 2008 OOP 168
Defining Derived Class

The general form of deriving a subclass from a base class is as follows
class derived-class-name : visibility-mode base-class-name { // .// members of the derived class };
The visibility-mode is optional. It may be either private or public or protected(default it is private) This visibility mode specifies how the features of base class are visible to the derived class.
U.K.R., 2008 OOP 169
Inheritance
Types of Inheritance Simple or Single Inheritance Multi level or Varied Inheritance Multiple Inheritance Hierarchical Inheritance Hybrid Inheritance Virtual Inheritance
U.K.R., 2008
OOP
170
Simple or Single Inheritance

This a process in which a sub class is derived from only one superclass. a Class Student is derived from a Class Person
superclass(base class) Person
class Person { /* */ }; class Student : public Person { /**/ };
Student
subclass(derived class) visibility mode

U.K.R., 2008 OOP 171
Multilevel or Varied Inheritance

The method of deriving a class from another derived class is known as Multiple or Varied Inheritance. A derived class CS-Student is derived from another derived class Student.
Person class Person { /**/ }; class Student : public Person { /**/ }; class CS -Student : public Student { /**/ };
OOP 172
Student
CS -Student
U.K.R., 2008
Multiple Inheritance
A class is inheriting features from more than one super class Class Part-time Student is derived from two base classes, Employee and Student
class Employee { /**/ }; class Student { /**/ }; class Part-time Student : public Employee, public Student { /**/ };
OOP 173
Employee
Student
Part-time Student
U.K.R., 2008
Hierarchical Inheritance
Many sub classes are derived from a single base class The two derived classes namely Student and Employee are derived from a base class Person.
class Person { /**/ }; class Student : public Person { /**/ }; class Employee : public Person { /**/ };
OOP 174
Person
Student
Employee
U.K.R., 2008
Hybrid Inheritance
In this type, more than one type of inheritance are used to derive a new sub class Multiple and multilevel type of inheritances are used to derive a class PG-Student class Person {
/**/ Person
}; class Student : public Person {
/**/
}; class Gate Scorer {
Student
Gate_Scorer
/**/
}; class PG - Student : public Student public Gate Scorer {
PG_Student
U.K.R., 2008
/**/
OOP
};
175
Virtual Inheritance
Person
class Person {
/**/
}; class Student : public Person {
Student
Employee
/**/
}; Class Employee : public Person {
/**/
};
Part-time Student
class Part-time Student : public Student, public Employee {
/**/
};
U.K.R., 2008 OOP 176
Virtual Inheritance
A sub class is derived from two super classes which in-turn have been derived from another class. The class Part-Time Student is derived from two super classes namely, Student and Employee. These classes in-turn derived from a common super class Person. The class Part-time Student inherits, the features of Person Class via two separate paths
U.K.R., 2008
OOP
177
Inheritance contd,
Four things you might find in an Inheritance Hierarchy
Super class is too general to declare all behavior, so each subclass adds its own behavior. Super class legislates an abstract behavior and therefore delegates implementation to super class. Super class specifies behavior, subclasses inherit behavior. Super class specifies behavior, subclasses choose to override behavior.
U.K.R., 2008
OOP
178
Access Specifiers with Inheritance
If we want an instance variable to be available for subclasses to change it, then we can choose access specifier protected. The following examples illustrates the usage of these access specifiers.
U.K.R., 2008
OOP
179
Access Specifiers with Inheritance

class X { int priv; protected: int prot; public: int publ; void m( ); }; void X::m( ) { priv =1; //Ok prot =1; //Ok publ =1; //Ok } class Y : public X { void mderived( ); };
U.K.R., 2008
Y::mderived( ) { priv =1; prot = 2; publ = 3;
//Error priv is private and //cannot be inherited // Ok // Ok
} void global_fun(Y *p) { p->priv = 1; //Error : priv is private of X p->prot = 2; //Error : prot is protected //and the function global_fun( ) // is not a friend or a member of X or Y p->publ =3; // Ok }
OOP
180
Public, Protected and Private derivation
Class A
private : int a1;
Class B
private : int b1;
Class B: Public A
private : int b1;
protected : int a2;
protected : int b2;
protected: int a2; int b2 public: int b3; int a3;
public : int a3;
public : int b3;
Public Derivation
U.K.R., 2008 OOP 181
Public derivation - example

class X { int priv; protected: int prot; public: int publ; void m( ); }; void X::m( ) { priv =1; //Ok prot =1; //Ok publ =1; //Ok } class Y : public X { void mderived( ); };
U.K.R., 2008
Y::mderived( ) { priv =1; prot =2; publ=3;
//Error priv is private and //cannot be inherited // Ok // Ok
} void global_fun(Y *p) { p->priv = 1; //Error : priv is //private of X p->prot = 2; //Error : prot is // protected and the function global_fun( ) // is not a friend or a member of X or Y p->publ =3; // Ok }
OOP
182
Protected derivation - example

The inherited public and protected members of a base class become protected members of the derived class
Class A
private : int a1; protected : int a2; public : int a3;
Class B
private : int b1; protected : int b2; public : int b3;
Class B : Protected A
private : int b1; protected: int a2; int b2,a3; public: int b3;
Protected Derivation
U.K.R., 2008 OOP 183
Protected derivation - example

class X { int priv; protected: int prot; public: int publ; void m( ); }; void X::m( ) { priv =1; //Ok prot =1; //Ok publ =1; //Ok } class Y : protected X { void mderived( ); };
U.K.R., 2008
Y::mderived( ) { priv =1; //Error priv is private and //cannot be inherited prot =2; // Ok publ=3; // Ok } void global_fun(Y *p) { p->priv = 1; //Error : priv is //private of X p->prot = 2; //Error : prot is //protected and the function global_fun( ) // is not a friend or a member of X or Y p->publ =3; // Error, protected }
OOP
184
Private derivation - example

The inherited public and protected members of a private derivation become private members of the derived class.
Class A
private : int a1; protected : int a2; public : int a3;
Class B
private : int b1; protected : int b2; public : int b3;
Class B : private A
private : int b1; int a1,a2,a3; protected: int b2; public: int b3;
Private Derivation
U.K.R., 2008 OOP 185
Private derivation - example

Class X { int priv; protected: int prot; public: int publ; void m( ); }; void X::m( ) { priv =1; //Ok prot =1; //Ok publ =1; //Ok } class Y : private X { void mderived( ); }; Y::mderived( ) { priv =1; //Error priv is private and //cannot be inherited prot =2; // Ok publ=3; // Ok U.K.R., 2008 }
class Z: public Y { public : void f() { prot=2;//error, prot is private to Y } }; void global_fun(Y *p) { p->priv = 1; //Error : priv is //private of X p->prot = 2; //Error : prot is //protected and the function global_fun( ) // is not a friend or a member of X or Y p->publ =3; // error }
OOP
186
Derived Class Constructors

A base class constructor is invoked, when a derived class object is created. If base class does not have default constructor, derived class constructor has to invoke base class constructor explicitly. Constructor of the base class will invoked before constructor of derived class
U.K.R., 2008
OOP
187

class B { int x; public : B( ) { cout << B::B( ) Fires << endl; } }; class D : public B { int y; public : D( ) { cout << D::D( ) Fires << endl; } }; void main( ) { D d; }
U.K.R., 2008 OOP
B::B( ) Fires D::D( ) Fires
188

class B { int a; public : B( ) { a = 0; cout<<B::B( ) Fires<<endl;} B(int x) { a =x; cout<<B::B(int) Fires<<endl; } }; class D : public B { int b; public : D( ) { b =0; cout<<D::D( ) Fires<<endl;} D(int x) { b =x; cout<<D::D(int) Fires<<endl;} D(int x, int y) : B(y) { b =x; cout<<D::D(int, int) Fires<<endl; } }; void main( ) { D d; D d(10); D d(10, 20); }
U.K.R., 2008 OOP
B::B( ) Fires D::D( ) Fires B::B( ) Fires D::D(int) Fires B::B(int) Fires D::D(int, int) Fires
189
Derived Class Destructors

Derived class destructors are called before base class destructors.
class B { int x; public : B( ) { cout<<B Constructor Invoked<<endl;} ~B( ) { cout<<B Destructor Invoked <<endl;} }; class D : public B { int y; public : D( ) { cout<<D Constructor Invoked <<endl;} ~ D( ) { cout<<D Destructor Invoked<<endl;} }; void main( ) { D d; }
B Constructor Invoked D Constructor Invoked D Destructor Invoked B Destructor Invoked
U.K.R., 2008
OOP
190
Overriding Member Functions

In the derived class, function inherited from base class, need to be redefined sometimes. When the same function exists in both the base class and the derived class, the function in the derived class is executed on derived class object
void main( ) { Employee e(John); Manager m(Mike,1); e.printDetails(); //Employee::printDetails invoked m.printDetails(); //Employee::printDetails invoked }
class Employee { protected : char name[50]; public : void printDetails() { cout << name; } class Manager : public Employee { protected: int type; }
class Manager : public Employee { public : void printDetails() { Employee::printDetails();cout << type; } }
U.K.R., 2008
m.printDetails(); //Manager::printDetails invoked
OOP
191
5. Polymorphism
Introduction:
In this Module one of the most important concept of OOPS i.e Polymorphism is discussed. Objective: After completing this module,you will be able to understand, Static Polymorphism Overloaded Functions Overloaded Operators Dynamic Polymorphism Virtual Functions
U.K.R., 2008 OOP 192
Polymorphism
Greek word meaning forms. many or multiple
In programming languages, polymorphism means that some code or operations or objects behave differently in different contexts It provides a single interface to entities of different types.
U.K.R., 2008
OOP
193
Types of polymorphism
Polymorphism
Static Polymorphism
Dynamic Polymorphism
Virtual Function
U.K.R., 2008
OOP
194
Polymorphism
Compiler determines a location in memory is called binding Connecting a function call to a function body is called Binding The location may represent the following Variable names bound to their storage memory address (offset) Function names bound to their starting memory address (offset) Two kinds of binding Compile-Time Binding Run-Time Binding
U.K.R., 2008 OOP 195
Static Polymorphism
Compile-time binding or early binding is called as static polymorphism. Compile-Time Binding means Compiler has enough information to determine an address (offset) Named variables have their addresses hard-coded during compilation Global variables are given offset from start of global data area Local variables are given offset from top of stack Objects are given offset from start of object data executable code contains address references
U.K.R., 2008 OOP 196
Function Templates
To create generic functions that admit any data type as parameters and return a value without having to overload the function with all the possible data types. Until certain point they fulfill the functionality of a macro. Compact way to make overloaded functions InstantiationGenerate separate functions for different data types.
U.K.R., 2008
OOP
197
Function Templates
Keyword for declaring function template Keyword class Name of the template data-type Function parameters of type template, primitive or user-defined
template < class identifier > ReturnType FunctionName(arguments of type identifier) template < class T > // or template< typename T > T square( T value1 ) { return value1 * value1; }
U.K.R., 2008 OOP 198
Function Templates
Examples: Finding the absolute value of a variable
Prototype (Declaration): template <class Type> Type abs(Type val);
Definition: template <class Type> Type abs(Type val) { if (val >= 0) return val; else return val; }
U.K.R., 2008 OOP 199
Function Templates
// definition of function template maximum In main( ) template < class T > maximum( int1, int2, int3 ) // or template < typename T > T maximum( T value1, T value2, T value3 ) { maximum( double1, double2, double3 ) T max = value1; if ( value2 > max ) max = value2; if ( value3 > max ) max = value3; maximum( char1, char2, char3 ) return max; } Output Maximum value Input values 1, 2, 3 3 1.1 , 2.1, 1.8 2.1 A, B, C C
U.K.R., 2008 OOP 200
Function Template Overloading

Other function templates with same name
Different parameters
template<class T> T sqrt(T); template<class T> complex<T> sqrt(complex<T>); double sqrt(double);
Non-template functions with same name

Different function arguments
Compiler performs matching process

Tries to find precise match of function name and argument types If fails, function template generates function-template specialization and uses most specialized one
complex<double> z; sqrt(1); //sqrt<int>(int) sqrt(2.0); //sqrt(double) sqrt(z); //sqrt<double>(complex<double>) //sqrt<double>(complex<double>) is more specilized than sqrt<complex<T>>(complex<double>) template<class T> class complex { T real, img; /**/ };
U.K.R., 2008
OOP
201
Template Function Specialization

By default a template gives a single definition to be used for every template argumentdoes not make sense always
template <class T> bool less(T a, T b) { return a<b?true:false; } less(2,5); less(3.4, 1.5); less(C++, Java);
Fails to compare two strings

template<> bool less<const char*>(const char *a, const char *b) { return strcmp(a,b); }
template<> bool less<>(const char *a, const char *b) { return strcmp(a,b); }
U.K.R., 2008 OOP
template<> bool less(const char *a, const char *b){ return strcmp(a,b); }
202
Template Function Specialization

Another example
class Stack { int size, top, *a; Stack operator=(const Stack&); /**/ } Stack s1(1000), s2(2000); swap(s1, s2); //inefficient template<class T> void swap(T &a, T &b) { T temp = a; a = b; b = temp; }
void Stack:::swap(Stack &s) { swap(size, s.size); swap(top, s.top); swap(a, s.a); }
//swap for Stack template<> void swap(Stack &a, Stack &b) { a.swap(b); }
U.K.R., 2008
OOP
203
Type Conversion
An Example main( ) { Index i(3); int x; x=i; i=x; } //int to Index conversion //Index to int conversion //int to Index conversion
Another Example main( ) { String lang(C++); char *str=lang;

U.K.R., 2008
//char * to String conversion //String to char* conversion

OOP 204
Type Conversion
Objects of a given class type can be converted to objects of another type This is done by constructing an object of the target class type from the source class type and copying the result to the target object. This process is called conversion by constructor Objects can also be converted by user-supplied conversion functions
Conversion required Conversion takes palce in Conversion takes palce in
Basic class Class basic Class class

U.K.R., 2008
Not applicable Casting Operator Casting operator

OOP
Constructor Not Applicable Constructor

205
Type Conversion
class Index { int x; public : Index(int i):x(i){} operator int() { return x; } }; main( ) { Index i(3); int x; x=i; i=x; }
U.K.R., 2008
//Index to int conversion operator
//int to index conversion //x=int(i) //i=Index(x)
OOP
206
Type Conversion
#include <string.h> class String { public: // Define constructor that converts //from type char * String( char *s ) { strcpy( _text, s ); } // Define operator conversion function //to type char * operator char *() { return _text; } } private: char _text[80]; };
U.K.R., 2008 OOP
int main() { String s( "abcd" ); char *str = "efgh"; strcpy(str,s); //strcpy(str, char*(s)); //String to char* conversion }
207
Ambiguity During Type Conversion

#include <string.h> class String { public: String( char *s ); operator char *(); private: char _text[80]; }; bool operator==(String , String ) ; The compiler has two choices and no way of determining which is correct. (i)It can convert ch to an object of type String using the constructor and then perform the comparison using the user-defined operator==. (ii)It can convert s to a pointer of type char * using the conversion function and then perform a comparison of the pointers.
int main() { String s( "abcd" ); char *ch = "efgh"; return s == ch; //ambiguity operator ==(s, String(ch)) or char*(s) == ch ? }U.K.R., 2008 OOP
208
Ambiguity During Type Conversion

class Index { int x; public : Index(int i):x(i){} operator int() { //Index to int conversion operator return x; } }; int operator +(Index, Index); main( ) { Index i(3); int x; x+i; //ambiguity, operator(Index(x), i) or x+int(i) ? }
U.K.R., 2008 OOP 209
Composition
Classes having objects of other classes as their data members - composite classes class y
{ class X { int i; public: x() { i = 0; } void set(int j) { i = j; } int read() const { return i; } };
U.K.R., 2008 OOP
int i; public: X x; Y() { i=0;} void f(int j) { i=j;} int g() const { return i;} }; int main() { Y y; y.f(5); y.x.set(10); }
210
Constructors in Composite Class

class X { int i; public: X(int ii=0):i(ii) { cout << Xs constructor; }; }; class Y { int j; public: Y(int jj=0):j(jj) { cout << Ys constructor; }; }; class Z { int k; public: Y y; X x; Z(int a, int b, int c) : x(a), y(b), k(c) { cout << Zs constructor; } int main() { Z z(1,2,3); } Output : Ys constructor Xs constructor Zs constructor
OOP 211
U.K.R., 2008
Polymorphism : NonVirtual Functions

Base class Pointer can point an object of its subclass Base class reference can refer an object of its subclass
class B{ public: void f(); }; class D: public B{ public: // f() not overridden }; void main(){ D d; D*pb = &d; //obvious B*pd = &d; //obvious d.f(); // B::f(), call f() through d pd->f(); // B::f(), call f() through a derived class pointer pb->f(); //B::f(), call f() through a base class pointer }
U.K.R., 2008 OOP
No matters style of call, function name and object type serve as basics for function body selection. All three calls of f( ) on derived class object d through the object, through a base class pointer and through a derived class pointer provides the same result.
212
class Employee { protected : char name[50]; public : void printDetails() { cout << name; } class Manager : public Employee { protected: int type; public : void printDetails() { Employee::printDetails(); cout << type; } }
U.K.R., 2008
void main( ) { Employee e(John), *eptr; Manager m(Mike,1); eptr = &e; //obvious eptr->printDetails();//Employee::printDetails() eptr = &m;//legal as Manager is an Employee eptr->printDetails(); //Employee::printDetails }
OOP
213
class Shape { public : void draw(); }; class Triangle : public Shape { public : void draw(); }; class Rectangle : public Shape { public : void draw(); }; class Circle : public Shape { public : void draw(); };
U.K.R., 2008
void main( ) { Shape *arr[3]; arr[0] = new Triangle; arr[1] = new Rectangle; arr[2] = new Circle; for(int i=0;i<3;i++) //draw all objects arr[i]->draw(); }
OOP 214
Polymorphism : Virtual functions

Virtual Functions
A member function that is declared as virtual in a base class and redefined by a derived class. A virtual function defines a general class of actions . The redefined virtual function implements a specific method. For non-virtual functions with the same name, the system determines at compile time which of the function to invoke. For virtual methods with the same name the system determines at run time which of the methods to invoke.
U.K.R., 2008 OOP 215
Virtual Functions : Example 1

Class B { public: virtual void g(); int h(); }; class D : public B { public: void g(); int h(); }; int main() { D d; B *ptr = &d; ptr->h(); B::h invoked ptr->g(); D::h invoked }
U.K.R., 2008
OOP
216
Virtual Functions : Example 2

class Base { public: virtual void fun() {cout<<This is base fun().\n; } }; class Derived0 : public Base { public: void fun() {cout<< This is derived0 fun().\n;} }; class Derived1 : public Base { public: void fun() { cout<< This is derived1 fun() .\n; } };
Output This is base fun() This is derive0 fun() This is derive1 fun()
U.K.R., 2008 OOP
int main() { Base *ptr B; Derived0 D0; Derived1 D1; ptr=&B; ptr->fun(); ptr=&D0; ptr->fun(); ptr=&D1; p->fun(); return 0; }
217
Virtual Functions : Constructors
Virtual functions should be member functions. To construct an object , a constructor needs the exact type of the object it is to create. So a constructor can not be virtual but a destructor can be.
U.K.R., 2008
OOP
218
Virtual Functions : Constructors contd

class B { public: B( ) { this->f(); } virtual void f() { cout<<Executing B::f()<<endln; } };
main() { D d; cout<<object d was created successfully<<endl; d.f(); }
class D: public B { public: D( ){ } virtual void f( ) { cout<<Executing D::f()<<endl; } };
output
Executing B::f() object d was created successfully. Executing D::f()
U.K.R., 2008
OOP
219
Virtual Functions : Destructors

class B { char * ptrB; public: B() { ptrB = new char[5]; cout<<B allocates 5 bytes\n; } ~B() { delete[] ptrB; cout<<B frees 5 bytes\n; } }; class D: public B { char*ptrD; public: D( ) : B() { ptrD=new char[1000]; cout<<D allocates 1000 bytes\n; } ~D() { delete[] ptrD; cout<< D frees 1000 bytes\n; } };
U.K.R., 2008
OOP
220
Virtual Functions : Destructors contd

void main() { while(1) f(); } void f() { B*p=new D; delete p; } The Memory will be exhausted, in each call of function f( ), B allocates 5 bytes D allocates 1000 bytes B frees 5 bytes.
As p is of type B*, p is bound to Bs data members and methods, including constructors and destructors rather than to Ds methods . When f exits B::~B frees the 5 bytes. D::~D() fails to fire.
U.K.R., 2008
OOP
221
Solution
class B { char * ptrB; public: B() { ptrB=new char[5]; cout<<B allocates 5 bytes\n; } virtual ~B() { delete []ptrB; cout<<B frees 5 bytes\n; } }; class D: public B { char*ptrD; public: D( ) : B() { ptrD=new char[1000]; cout<<D allocates 1000 bytes\n; } ~D() { delete[] ptrD; cout<< D frees 1000 bytes\n; } };
U.K.R., 2008
OOP
222
Virtual Function : Default Arguments

The default argument is not determined at run time, rather it is determined at compile time and is based on the type of the object through which the function is being invoked.
class Base { public: virtual int foo(int ival=1024){ cout<<base::foo()ival :<<ival <<endl; return ival; } }; class Derived :: public Base{ public: virtual int foo(int ival=2048) { cout<<derived::foo() ival : << ival << endl; return ival; } };
U.K.R., 2008 OOP 223
Virtual Function : Default Arguments contd

int main () { Derived *pd=new derived; Base *pb=pd; int val = pb->foo(); cout<<main : val through base <<val<<endl; val = pd->foo(); cout<<main : val through derived <<val<<endl; } Output
derived:: foo() ival : 1024 main : val through base : 1024 derived :: foo() ival : 2048 main : val through derived : 2048
The default argument to be passed to foo() is not determined at run time, rather it is determined at compile time and is based on the type of the object through which the function is being invoked.
U.K.R., 2008 OOP 224
Abstract Class & Pure Virtual Functions

Abstract Class A class that serves only as a base class from which other classes can be derived ; no instance of an abstract base class are ever created. If a base class declares a pure virtual functions , no instance of the class can be created, and so it is necessarily an abstract base class. Pure Virtual Functions A virtual function that is declared in a base but not defined there ; responsibility for defining the function falls on the derived classes, each of which generally provides a different definition.
U.K.R., 2008
OOP
225
Pure Virtual Function

class Base { public: virtual void show()=0; // Pure Virtual function }; class Derv1 : public Base { public: void show(){ cout<<\n Derv 1; } }; class Derv2 : public Base{ public: void show(){cout<<\n In Derv2; } }; void main(){ Base *List[2]; Derv1 dv1; Derv2 dv2; List[0]=&dv1; List[1]=&dv2; List[0]->show(); List[1]->show(); }
OOP 226
U.K.R., 2008
Pure Virtual Function

class Shape { public: virtual void draw()=0; // Pure Virtual function }; class Shape2D : public Shape { public: virtual float area()=0; // Pure Virtual function }; class Circle : public Shape2D { public: void draw(); float area(); // concrete functions };
U.K.R., 2008 OOP
class Shape3D : public Shape { public: virtual float volume(); // Pure Virtual function }; class Cube : public Shape3D { public: void draw(); float volume(); // concrete functions };
227
Virtual Function & Private/Protected Derivation

Polymorphism does not work with private or protected derivation
class Base{ public: virtual void f(); }; class Derived : private Base{ public: void f(); }; Base *ptr, b; Derived d; ptr=&d; // illegal ptr=&b; // ok ptr->f(); // calls B::f()
U.K.R., 2008
Standard conversions dont convert derived class pointers to base class pointers with private/protected derivation. Always use public inheritance with polymorphism.
OOP
228
Virtual Function Implementation

Most compiler build a virtual function table for each polymorphic class. All object of the same class share the same virtual function table(vtable). The vtable is an array of pointers to virtual functions that have definitions in either a base class or a derived class . The value of the pointer depends on whether or not the derives class override a base class virtual function with a new version of its own. A polymorphic class with at least one virtual function includes a hidden pointer (vptr) to its object which points to vtable.
U.K.R., 2008 OOP 229
Virtual Function Implementation

contd
Base vtbl;
Base::f1()
Base b1;
Base Members vptr
Base::f2() Base::f3()
Derived d1;
Base Members vptr Derived Members
Derived vtbl;
Base::f1() Derived::f2() Base::f3() Derived::f4()
U.K.R., 2008
OOP
230
Virtual Function Example 4

class Base{ public : Base() { } virtual void f1() { cout<<base::f1( ) << endl; } virtual void f2( ) { cout << Base:: f2()<<endl; } virtual void f3() { cout<<Base :: f3()<<endl; } }; class Derived { public: Derived() { } void f2() { cout<<Derived ::f2()<<endl; } virtual void f4() { cout<<Derived ::f4()<,endl;} };
U.K.R., 2008 OOP
Base b1; Derived d1; Base *p=&d1; p->f4(); // illegal Derived *q=&d1; q->f4() ;// legal
With the help of base class pointer, we cant access any derived class members.
231
Object Oriented Programming: Next Step

ll Book Book PDF URL Description OO A & D by Grady Booch Object oriented software concepts by Bertrand Mayer http://www.kbcafe.com/articles/OOP. Concepts.pdf Reference Topic or Module All All All
http://www.desy.de/gna/html/cc/Tutor All ial/tutorial.html http://www.bitpipe.com/rlist/term/Obj ect-Oriented-Programming.html All
http://www.well.com/user/ritchie/oo.h All tml http://www.planetpdf.com/codecuts/p All dfs/ooc.pdf

U.K.R., 2008 OOP 232
Congratulations! You have successfully completed
U.K.R., 2008
OOP
233

Oop

Hochgeladen von

Dokumentinformationen

Originalbeschreibung:

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Oop

Hochgeladen von

Copyright:

Verfügbare Formate

Object Oriented Programming

BPCL C Algol68 Algol68 Simula67 Simula67 (Smalltalk) (Ada) (LISP)

Strengths and Weakness of C

Examples of OOP Language

Languages with OO Extensions

Languages with OO look and feel

Differences between C and C++

Key Words for C and C++

delete friend protected public virtual

Non-Object Oriented Extension from C to C++

struct A { int x; }; A a; enum E {ee}; E e;

C style cast Function notation cast

int i, j; //C style float g = (float)i/2; //function notation float h = float(j)/2

Impossibility of accidental modification of data Increases readability

Const and #define

#define x 4-2 main( ) { int y = x*x; }

const int x = 4-2; main( ) { int y = x*x; }

Const and #define

Constants and Pointers

DataType & ReferenceVariable = OriginalVariable

Properties of a reference variable

Constants and References

void change(int a, int b) { int temp; temp = a; a = b; b = temp; }

//a,b formal params

void change(int &a, int &b) { int temp; temp = a; a = b; b = temp; }

//a,b formal args

Danger with references

Possible solutionuse const

Possibility to write generic function

int x = 2; int &f() { return x; }

inline ReturnType FunctionName(Parameters) { // Body of a main function }

inline int fact(int n { return (n < 2?1:n*fact(n-1)); }

void main( ) { // a = 120; b = 4*fact(3); cin >> n; c = fact(n); // }

Inline Functions versus Macros

Inline Functions versus Macros

Inline Functions versus Macros

Overloaded function resolution

//ambiguity:which sum? sum(int(1.1), int(1.1)) or sum(float(1.1), float(2.2)?

int myFunction(int x = 1,int y = 2,int z = 3)

Object Oriented Programming

Member Function Data variable Member Function

Data variable Member Function

Object Oriented programming?

Benefits of Object Orientation

Benefits of Object Orientation

Classes and Objects

Atrributes and their class

Student roll::Integer name::String address::String birthDate::Date attributes

PC hdd::Component ram::Memory Mouse::InputDevice keyboard::OutputDevice attributes

Atrributes and their class

Atrributes and their class

reset() setAlarm(t: Temperature) Value(): Temperature Operations

Register endSale() enterItem(id: ItemId, qty: Integer) pay(cashTendered: Money) Operations

+execute() +rollback() #priority() -timestamp()

Rectangle tl: Point rb: Point area(): Float

Circle radius: Float center: Point area(): Float

Polygon points:List area(): Float display()

Square leaf class

Classes & Objects

Initialization of member variables

Classes & Objects

Initialization of member variables

int main () { Complex c1(2,3), c2(4,5), c3; c3=c1+c2; c1=c1+c2c3; c3=c1c3; }