Scribd
Upload
79 views23 pages

More C++ Concepts: - Operator Overloading - Friend Function - This Operator - Inline Function

The document discusses various C++ concepts including operator overloading, friend functions, the this operator, and inline functions. Operator overloading allows programmers to define special member functions to customize object behaviors. There are three ways to implement operator overloading: as member functions, non-member functions, or friend functions. The this pointer refers to the current object within member functions. Inline functions have their code inserted directly instead of generating function calls to improve performance for short functions.

Uploaded by

Ankesh Kunwar
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
79 views23 pages

More C++ Concepts: - Operator Overloading - Friend Function - This Operator - Inline Function

The document discusses various C++ concepts including operator overloading, friend functions, the this operator, and inline functions. Operator overloading allows programmers to define special member functions to customize object behaviors. There are three ways to implement operator overloading: as member functions, non-member functions, or friend functions. The this pointer refers to the current object within member functions. Inline functions have their code inserted directly instead of generating function calls to improve performance for short functions.

Uploaded by

Ankesh Kunwar
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 23

More C++ Concepts

Operator overloading Friend Function This Operator Inline Function

Operator overloading
Programmer can use some operator symbols to define special member functions of a class
Provides convenient notations for object behaviors

Why Operator Overloading


int i, j, k; float m, n, p; // integers // floats The compiler overloads the + operator for built-in integer and float types by default, producing integer addition with i+j, and floating addition with m+n.

k = i + j; // integer addition and assignment p = m + n; // floating addition and assignment

We can make object operation look like individual int variable operation, using operator functions Complex a,b,c; c = a + b;
3

Operator Overloading Syntax


Syntax is:
operator@(argument-list)

Examples:
operator+ operator-

operator*
operator/ --- operator is a function

--- @ is one of C++ operator symbols (+, -, =, etc..)

Example of Operator Overloading


class CStr { char *pData; int nLength; public: // void cat(char *s); // CStr operator+(CStr str1, CStr str2); CStr operator+(CStr str, char *s); CStr operator+(char *s, CStr str); //accessors char* get_Data(); int get_Len(); }; }
5

void CStr::cat(char *s) { int n; char *pTemp; n=strlen(s); if (n==0) return; pTemp=new char[n+nLength+1]; if (pData) strcpy(pTemp,pData);

strcat(pTemp,s); pData=pTemp; nLength+=n;

The Addition (+) Operator


CStr CStr::operator+(CStr str1, CStr str2) { CStr new_string(str1);
//call the copy constructor to initialize an //entirely new CStr object with the first //operand

new_string.cat(str2.get_Data());
//concatenate the second operand onto the //end of new_string

return new_string;
//call copy constructor to create a copy of //the return value new_string

}
new_string str1 strcat(str1,str2) strlen(str1) strlen(str1)+strlen(str2)

How does it work?


CStr first(John); CStr last(Johnson); CStr name(first+last);

CStr CStr::operator+(CStr str1,CStr str2) { CStr new_string(str1); new_string.cat(str2.get()); return new_string; }

name
Copy constructor

John Johnson
Temporary CStr object
7

Implementing Operator Overloading


Two ways:
Implemented as member functions Implemented as non-member or Friend functions the operator function may need to be declared as a friend if it requires access to protected or private data
Expression obj1@obj2 translates into a function call obj1.operator@(obj2), if this function is defined within class obj1 operator@(obj1,obj2), if this function is defined outside the class obj1
8

Implementing Operator Overloading


1. Defined as a member function
class Complex { ... public: ... Complex operator +(const Complex &op) { double real = _real + op._real, imag = _imag + op._imag; return(Complex(real, imag)); } ... };

c = a+b;

c = a.operator+ (b);

Implementing Operator Overloading


2. Defined as a non-member function
class Complex { c = a+b; ... public: ... double real() { return _real; } c = operator+ (a, b); //need access functions double imag() { return _imag; } ... Complex operator +(Complex &op1, Complex &op2) }; { double real = op1.real() + op2.real(), imag = op1.imag() + op2.imag(); return(Complex(real, imag)); 10 }

Implementing Operator Overloading


3. Defined as a friend function
class Complex { c = a+b; ... public: ... friend Complex operator +( c = operator+ (a, b); const Complex &, const Complex & ); Complex operator +(Complex &op1, Complex &op2) ... { }; double real = op1._real + op2._real, imag = op1._imag + op2._imag; return(Complex(real, imag)); 11 }

Ordinary Member Functions, Static Functions and Friend Functions

1. The function can access the private part of the class definition 2. The function is in the scope of the class 3. The function must be invoked on an object
Which of these are true about the different functions?

12

What is Friend?
Friend declarations introduce extra coupling between classes
Once an object is declared as a friend, it has access to all non-public members as if they were public

Access is unidirectional

If B is designated as friend of A, B can access As non-public members; A cannot access Bs

A friend function of a class is defined outside of that class's scope


13

More about Friend


The major use of friends is
to provide more efficient access to data members than the function call to accommodate operator functions with easy access to private data members

Friends can have access to everything, which defeats data hiding, so use them carefully Friends have permission to change the internal state from outside the class. Always recommend use member functions instead of friends to change state
14

Assignment Operator
Assignment between objects of the same type is always supported
the compiler supplies a hidden assignment function if you dont write your own one same problem as with the copy constructor - the member by member copying Syntax:

class& class::operator=(const class &arg) { // }


15

Example: Assignment for CStr class


Assignment operator for CStr: CStr& CStr::operator=(const CStr & source)
Return type - a reference to (address of) a CStr object

Argument type - a reference to a CStr object (since it is const, the function cannot modify it)

CStr& CStr::operator=(const CStr &source){ //... Do the copying return *this; Assignment function is called as a }

str1=str2;

member function of the left operand =>Return the object itself

str1.operator=(str2)

Copy Assignment is different from Copy Constructor


16

The this pointer


Within a member function, the this keyword is a pointer to the current object, i.e. the object through which the function was called C++ passes a hidden this pointer whenever a member function is called Within a member function definition, there is an implicit use of this pointer for references to data members

this pData

Data member reference pData nLength

Equivalent to this->pData this->nLength

nLength
CStr object (*this)

17

Overloading stream-insertion and stream-extraction operators


In fact, cout<< or cin>> are operator overloading built in C++ standard lib of iostream.h, using operator "<<" and ">>" cout and cin are the objects of ostream and istream classes, respectively We can add a friend function which overloads the operator <<
friend ostream& operator<< (ostream &os, const Date &d);

ostream& operator<<(ostream &os, const Date &d) { os<<d.month<</<<d.day<</<<d.year; return os; cout ---- object of ostream }
cout<< d1; //overloaded operator
18

Overloading stream-insertion and stream-extraction operators


We can also add a friend function which overloads the operator >>
friend istream& operator>> (istream &in, Date &d);

istream& operator>> (istream &in, Date &d) { char mmddyy[9]; in >> mmddyy; // check if valid data entered if (d.set(mmddyy)) return in;

cin ---- object of istream

cout<< "Invalid date format: "<<d<<endl; exit(-1);


}
cin >> d1;
19

Inline functions
An inline function is one in which the function code replaces the function call directly. Inline class member functions
if they are defined as part of the class definition, implicit if they are defined outside of the class definition, explicit, I.e.using the keyword, inline.

Inline functions should be short (preferable one-liners).


Why? Because the use of inline function results in duplication of the code of the function for each 20 invocation of the inline function

Example of Inline functions


class CStr { char *pData; int nLength; Inline functions within class declarations public: char *get_Data(void) {return pData; }//implicit inline function int getlength(void); }; inline void CStr::getlength(void) //explicit inline function { return nLength; } Inline functions outside of class declarations int main(void) { char *s; int n; CStr a(Joe); s = a.get_Data(); n = b.getlength(); }

In both cases, the compiler will insert the code of the functions get_Data() and getlength() instead of generating calls to these functions
21

Inline functions (II)


An inline function can never be located in a run-time library since the actual code is inserted by the compiler and must therefore be known at compile-time. It is only useful to implement an inline function when the time which is spent during a function call is long compared to the code in the function.
22

Take Home Message


Operator overloading provides convenient notations for object behaviors There are three ways to implement operator overloading
member functions normal non-member functions friend functions
23

You might also like