Object oriented Programming
Lecture 8: Operator overloading
Object oriented programming in C++ by Robert Lafore 1
Recap..
• Static and const attributes and functions
• Array of pointers
• Pointers to objects
• This pointer
• Array of pointers to objects
• Cascading function calls
Object oriented programming in C++ by Robert Lafore 2
Recommended reads
Object oriented programming in C++ by Robert Lafore: Chapter 8: Operator
Overloading
Object oriented programming in C++ by Robert Lafore 3
Copy constructor [Revisiting]
• C++ compiler provide default copy constructor (and assignment operator) with class.
• When we don’t provide implementation of copy constructor, default copy constructor
gets called
• It works well with non-dynamic attributes
• Problems:
• When we have members which dynamically gets initialized at run time, default copy
constructor copies this members with address of dynamically allocated memory and not
real copy of this memory.
• Now both the objects points to the same memory and changes in one reflects in another
object
• Further, when we delete one of this object other object still points to same memory,
which will be dangling pointer
• in such cases, we should always write our own copy constructor
Object oriented programming in C++ by Robert Lafore 4
ClassName (const ClassName &old_obj);
class Point int main()
{ {
private: Point p1(10, 15); // Normal constructor is called here
int x, y; Point p2 = p1; // Copy constructor is called here
public: }
Point(int x1, int y1) { x = x1; y = y1; }
// Copy constructor
Point(const Point &p2) {x = p2.x; y = p2.y; }
int getX() { return x; }
int getY() { return y; }
};
Object oriented programming in C++ by Robert Lafore 5
• Default constructor does only shallow copy
• Deep copy is possible only with user defined copy constructor. In user defined
copy constructor, we make sure that pointers (or references) of copied object
point to new memory locations.
• Copy constructor vs Assignment Operator
• MyClass t1, t2;
• MyClass t3 = t1; // ----> (1)
• t2 = t1; // -----> (2)
• Copy constructor is called when a new object is created from an existing object,
as a copy of the existing object.
• Assignment operator is called when an already initialized object is assigned a new
value from another existing object.
• In the above example (1) calls copy constructor and (2) calls assignment operator.
Object oriented programming in C++ by Robert Lafore 6
Default assignment operator= in c++ is a shallow copy
class Test
{
public: int main()
Test() {} {
Test(const Test &t) Test t1, t2;
{ t2 = t1; //Default Assignment operator
cout<<"Copy constructor called "<<endl; Test t3 = t1; //copy constructor
} return 0;
}
Test& operator = (const Test &t)
{
cout<<"Assignment operator called "<<endl;
return *this; t2 = t1; // calls assignment operator, same as "[Link]=(t1);"
} Test t3 = t1; // calls copy constructor, same as "Test t3(t1);"
};
Object oriented programming in C++ by Robert Lafore 7
Shallow copy
Class Dummy
public: int main()
Int *x; {
Dummy(int m) Dummy d1(4);
{ Dummy d2 = d1; //Copy constructor
x = new int; [Link]();
*x = m; [Link]();
}
[Link](10);
int get() const
{
[Link]();
return *x; [Link]();
} return 0;
void set(int m) }
{
*x = m;
}
void display()
{
cout << “Value of ptr : " << *x << endl;
cout << “Address of ptr : " << x << endl;
}
};
Object oriented programming in C++ by Robert Lafore 8
Deep copy
Class Dummy
public: int main()
Int *x; {
Dummy(int m) Dummy(const Dummy &obj) Dummy d1(4);
{ { Dummy d2 = d1; //Copy constructor
x = new int; x = new int; [Link]();
*x = m; *x = [Link](); [Link]();
} } [Link](10);
int get() const
{
[Link]();
return *x; [Link]();
} return 0;
void set(int m) }
{
*x = m;
}
void display()
{
cout << “Value of ptr : " << *x << endl;
cout << “Address of ptr : " << x << endl;
}
};
Object oriented programming in C++ by Robert Lafore 9
Operator overloading
• statements like [Link](d1, d2); Or d3 = [Link](d2);
can be changed to the much more readable d3 = d1 + d2;
• normal C++ operators works for basic data types such as int, double, char..
a=b+c
• Using overloading, you can make this statement legal even when a, b, and c are
user-defined types.
• Overloaded function with operator keyword: void operator ++ ()
Object oriented programming in C++ by Robert Lafore 10
Overloading Unary Operators
• increment and decrement operators ++ and –
Object oriented programming in C++ by Robert Lafore 11
Prefix increment: ++object
class Counter int main()
{ {
private: Counter c1, c2; //define and initialize
unsigned int count; //count cout << “\nc1=” << c1.get_count(); //display
public: cout << “\nc2=” << c2.get_count();
Counter() : count(0) //constructor ++c1; //increment c1
{} ++c2; //increment c2
unsigned int get_count() //return count ++c2; //increment c2
{ return count; } cout << “\nc1=” << c1.get_count(); //display again
void operator ++ () //increment (prefix) cout << “\nc2=” << c2.get_count() << endl;
{ return 0;
++count; }
}
};
Object oriented programming in C++ by Robert Lafore 12
Counter operator ++ () //increment count int main()
{ {
++count; //increment count Counter c1, c2; //c1=0, c2=0
Counter temp; //make a temporary Counter cout << “\nc1=” << c1.get_count(); //display
[Link] = count; //give it same value as this obj cout << “\nc2=” << c2.get_count();
return temp; //return the copy c2 = ++c1; //c1=1, c2=1
} }
Object oriented programming in C++ by Robert Lafore 13
Nameless Temporary Objects
class Counter Counter temp;
{ [Link] = count;
private: return temp;
unsigned int count; //count
public: int main()
Counter() : count(0) //constructor no args {
{} Counter c1, c2; //c1=0, c2=0
Counter(int c) : count(c) //constructor, one arg cout << “\nc1=” << c1.get_count(); //display
{} cout << “\nc2=” << c2.get_count();
unsigned int get_count() //return count c2 = ++c1; //c1=2, c2=2
{ return count; } }
Counter operator ++ () //increment count
{
++count; // increment count, then return
return Counter(count); // an unnamed temporary
object
} // initialized to this count
};
Object oriented programming in C++ by Robert Lafore 14
Using parametrized constructor inside overloaded function
class Counter Counter temp;
{ [Link] = count;
private: return temp;
unsigned int count; //count
public: int main()
Counter() : count(0) //constructor no args {
{} Counter c1, c2; //c1=0, c2=0
Counter(int c) : count(c) //constructor, one arg cout << “\nc1=” << c1.get_count(); //display
{} cout << “\nc2=” << c2.get_count();
unsigned int get_count() //return count c2 = ++c1; //c1=2, c2=2
{ return count; } }
Counter operator ++ () //increment count (prefix)
{
return Counter(++count); //an unnamed temporary
object
}
};
Object oriented programming in C++ by Robert Lafore 15
Postfix increment: object++
class Counter int main()
{ {
private: Counter c1, c2; //define and initialize
unsigned int count; //count cout << “\nc1=” << c1.get_count(); //display
public: cout << “\nc2=” << c2.get_count();
Counter() : count(0) //constructor c2 = c1++;
{} cout << “\nc1=” << c1.get_count(); //display again
Counter(int c) : count(c) //constructor, one arg cout << “\nc2=” << c2.get_count() << endl;
{} return 0;
unsigned int get_count() //return count }
{ return count; }
Counter operator ++ (int) //increment count (postfix)
{
return Counter(count++); OR
} c2 = [Link]++;
};
Object oriented programming in C++ by Robert Lafore 16
Overloading Binary Operators
dist3.add_dist(dist1, dist2);
• By overloading the + operator we can reduce this dense-looking expression to
dist3 = dist1 + dist2;
OR
dist3 = [Link]+(dist2);
Object oriented programming in C++ by Robert Lafore 17
Distance Distance::operator + (Distance d2) //return sum
{ Main():
int f = feet + [Link]; //add the feet
float i = inches + [Link]; //add the inches Distance dist1, dist3, dist4; //define distances
return Distance(f,i); [Link](); //get dist1 from user
} Distance dist2(11, 6.25); //define, initialize dist2
dist3 = dist1 + dist2;
Object oriented programming in C++ by Robert Lafore 18
Concatenating strings
String operator + (String ss) const //add Strings
• str3 = str1 + str2; {
String temp; //make a temporary String
class String //user-defined string type strcpy([Link], str); //copy this string to temp
{ strcat([Link], [Link]); //add the argument string
private: return temp; //return temp String
char str[80]; //holds a string }
public: };
String() Main()
{ strcpy(str, “”); }
String( char s[] ) String s1 = “\nMerry Christmas! “; //uses constructor 2
{ strcpy(str, s); } String s2 = “Happy new year!”; //uses constructor 2
void display() const String s3;
{ cout << str; }
s3 = s1 + s2; //add s2 to s1,
[Link]();
Object oriented programming in C++ by Robert Lafore 19
Arithmetic Assignment Operators
void Distance::operator += (Distance d2)
{ dist1 += dist2; //dist1 = dist1 + dist2
feet += [Link]; //add the feet
inches += [Link]; //add the inches
}
Object oriented programming in C++ by Robert Lafore 20
That’s it
Object oriented programming in C++ by Robert Lafore 21
