Chapter 9. Operator Overloading. Dr Ahmed Rafat

Size: px

Start display at page:

Download "Chapter 9. Operator Overloading. Dr Ahmed Rafat"

Jewel Tucker
5 years ago
Views:

1 Chapter 9 Operator Overloading

2 Overloading Operators Overloading Basics How Operators are Overloaded Arithmetic Operators Fstring Class Example Cast Operator Equality and Relational Operators

3 Bitwise Operators Shifting Bits Bitwise AND Bitwise OR Bitwise Exclusive OR Bitwise NOT BitArray Class Example

4 How Operators are Overloaded

5 Operator Overloading: Refers to the technique of ascribing new meaning to standard operators, such as +, >>, and = when used with class operands. Operator Function: Is a function whose name consists of the keyword operator. Home

6 Unary Operator: Is an operator that has only a single operand. Example : ++ increment -- decrement ( ) function call [ ] subscript + plus - minus! Logical Not

7 Binary Operator: Is an operator that has two operands. Example : + Addition - Subtraction * Multiplication / Division % Modulus = Assignment += additional with assignment -= subtraction with assignment *= multiplication with assignment /= division with assignment %= modulus with assignment

8 Binary Operator cont. & bitwise AND bitwise OR ^ bitwise exclusive OR logical OR && logical AND == equal!= not equal > greater than < less than >= greater than or equal <= less than or equal << left shift <<= left shift with assignment >> right shift >>= right shift with assignment

9 Operator function must be either a non-static member function or a non-member function having at least one parameter, whose type is a class, reference to a class, enumeration, or reference to an enumeration. For example // Invalid Code int operator + ( int x, int y) return x+y; }

10 // valid because at least one parameter is a class type class Integer. public: int value; }; int operator = (const Integer & x, int y) return x.value+y; }

11 Arithmetic Operators

12 We define a class called Time that perform range checking and operations on time values. The Time class prevents users from assigning illegal values to hours and minutes, and provides a convenient way for incrementing the minutes in an hour.

13 Implementing the prefix ++ operator Prefix operator : returns the time value after it was incremented. We add 1 to the minutes and check to see if they have 59 If so, we increment the hour. If the hour exceeds 23, we roll it over to zero with the modulus % operator. const Time & Time::operator ++( ) if ( ++minutes > MinuteMax ) minutes = 0; hours = ( hours + 1 ) % ( HoursMax + 1 ); } return *this; }

14 Implementing the postfix ++ operator Postfix operator: returns the time value before it was incremented. We have to save the current Time, call the prefix ++ operator, and return the saved Time. Time Time::operator ++ ( int ) Time save ( *this ); operator ++ ( ); return save; } // Copy Constructor // Increment the time // Return the copy

15 Implementing the += operator Time class has an addition-assignment operator that add n minutes to the current time. After adding n to the minutes, we check for possible overflow by using modulus and integer division. const Time & Time::operator += ( unsigned n ) unsigned t = minutes + n; minutes = t % ( MinuteMax + 1); // Remaining Minutes hours += t / ( MinuteMax + 1 ); // Add to hours hours = hours % ( HoursMax + 1); // Roll over to next day return *this; }

16 Example If current time were 12:50 and we added 25 minutes t would become ( 50+25=75). minutes would become 15 ( t mod 60 ) and hours would become 13 ( 12+= t/60)

17 Test the Time class We create several Time objects, initialize them with variety of values, increment them, and display their new values. } void Test ( ) Time a; Time b (1845); cout<<++a<< \n // 00:01 <<b++<<endl; // 18:45 Time c (2359); cout<<( c += 15)<< \n ; // 00:14 Time d (1230); for (unsigned i=0; i<50; i++) cout<<++d<<, <<endl; cout<<endl;

18 Notice that : Time a is incremented before it is written to the output stream; Time b is written to the stream before being incremented. // Main function int main( ) try test( ); // Test the time class } catch ( const RangeError & R ) cout<<r; } return 0; }

19 Output

20 Fstring Class Example

21 Copy Constructor The following two statements both call the copy constructor Fstring s2(s1); Fstring s2=s1; Second statement doesn t call operator = Assignment Operator The following statement calls operator = s2=s1; Operator = returns a reference to the current Fstring, allowing it to be used in nested expression such as S1=S2= Filemore ; If the function returns an Fstring object ( rather than a reference ), the function would have to construct a temporary Fstring and return a copy of the current Fstring object. This would waste processing time and memory.

22 Implementing the += operator Fstring class has an addition-assignment operator that attaches another string to the end of the current one Fstring & Fstring::operator +=( const Fstring & s) size_t n=strlen( str ) + strlen (s.str); if(n>= MaxSize) throw RangeError( FILE, LINE,n); strcat ( str, s.str); return *this; } We have improved it here by having it throw a RangeError exception. If the combined length of the two strings exceeds MaxSize.

23 Implementing the Assignment operator The = operator, used for assigning a new string to the current one. First implementation assigns the Fstring parameter to the current string, making sure that the current string and d are not the same object. Fstring & Fstring::operator = (const Fstring & s) if ( *this ==s ) // can t assign object to itself return *this; size_t n= strlen (s.str); if ( n>maxsize ) throw RangeError ( FILE, LINE,n); strcpy ( str, s.str ); return *this; }

24 Second implementation converts const char* parameter to an Fstring and calls the first operator = function Fstring & Fstring::operator = ( const char *s ) return *this = Fstring (s); } Third implementation stores the character parameter in the first position of the string and appends NULL byte Fstring & Fstring::operator = ( char ch ) str [0] = ch; str [1] = \0 ; return *this; }

25 Cast Operator Cast operator is useful for performing conversion between a class object and some other types. Example : We might want to provide way of converting an Fstring object containing a string of digits into long. Fstring class would include the following declaration of member function that cast into long class Fstring public : operator long ( ) const; //. };

26 The declaration syntax is unusual in that it doesn t show a return type, the return type is understand to be the target type of the cast, in this case, long. #include<stdlib.h> Fstring::operator long ( ) const return strtol (str,0,0); } Cast operator can also use a pointer as its target type. For Example : we might need to convert an Fstring object to char * in order to pass it to function. class Fstring public: operator const char * ( ) const; //. }; Fstring::operator const char * ( ) const return str; }

27 There can t be an implicit conversion from a new type to an existing type unless we purse one of two alternatives : First alternative : involves changing the interface of an existing class, which can cause for reaching changes to user code. Second alternative : adding a cast operator to the new class, is preferable because it affects only the new class.

28 Equality and Relational operators

29 When it is reasonable to compare two instances of the same class, it is a good idea to overload the equality ( == and!= ) and relational (>,<,<=,>+) operators. For example : we declare two operands that compare student objects by their ID numbers. class Student public : int operator == ( const Student & s ) const ; int operator < ( const Student & s) const ; private : long id ; }; int Student::operator == (const Student & s) const return id == s.id ; } int Student::operator < ( const Student & s ) const return id < s.id ; }

30 Non-Member operator Functions The stream output operator, for example, is customarily placed at the right of a stream object or reference to a stream object, and at the left of expression being written to the stream: point p; cout<<p; But this order of operands would not be possible if the operator << function were a class member. This is what declaration would look like : class Point public: ostream & operator << ( ostream & os ); //. };

31 Point object would have to invoke the operator function, or point would have to appear as left-hand operand in a binary expression. point p; p.operator << ( cout ); p<<cout; // Function call // Same effect To declare this operator as non-member function, in which first argument is stream and second id point. This allows the operands to appear in the normal order with the stream at the left and point at the right. point p; cout<<p; ostream & operator <<( ostream & os, Const point & p ) os<<p.getx( )<<, <<p.gety( ); return os; } If the function required direct access to the private point data members, we could declare it as a friend of the point class.

32 Output

33 Bitwise Operators

34 We will introduce a class called BitArray that makes extensive use of bitwise operators.we assume that all values are unsigned. Using unsigned integers n and j. Quick summary of the operator n << j n is shifted j bits to the left n >> j n is shifted j bits to right n & j n is ANDed with j n j n is ORed with j n ^ j n is exclusive ORed with j ~ n n is NOTed

35 Shifting Bits

36 The shift operator moves all bits in an operand either lift or right. For example, n is type unsigned char and represented by eight bits. As n is shift to the lift. The highest bit disappears,each of the other bits moves one position to the left,and the lowest bit position is cleared(set to 0): n = unsigned char n; n=0xcf; n = n << 1; n= When n is shifted to the right, the lowest bit disappers,other bits are moved to the right, and the highest position is cleared unsigned char n; n = n=0xcf; n=n>>1; n =

37 Bitwise AND

38 When two bitwise ANDed together, each bit in the first is matched to its corresponding bit in the second.the resulting bit is 1 only if the two input bits were1.for unsigned character values n and j. n= j= n & j =

39 Bitwise OR

40 When two bitwise ORed together, each bit in the same position of the numbers is matched up.the resulting bit is always 1 unless both of the input bits were 0.For unsigned character values n and j. n = j = n j =

41 Bitwise Exclusive OR

42 When two bitwise exclusive ORed together, each bit in the numbers are matched up.the resulting bit is 1 only if two input bits were different.for unsigned character values n and j. n = j = n ^ j = The exclusive OR can be used to reverse,or toggle the bits in a number. This is done by excluvise ORing a number with all 1 s : n = j = n ^ j =

43 Bitwise NOT

44 The bit wise NOT operator also toggles all bits a number: n = ~n =

45 BitArray Class Example

46 No data type exist to store unlimited number of bits. The maximum number of bit is 64 (Long) Q What if we want to store 128 bit? Solution: What data type can be used?! Encapsulate data about bits in a class called BitArray

47 BitArray Class Definition Specify the size of the array at runtime Allocate a dynamic memory for the array storing the bits The class includes a default constructor, that lets the caller determine the array size, a destructor, assignment operator, set union operator( =), set intersection operator(&=) as will << and >> stream I/o operator The Reset function : clear one or all bits The set function : set one or all bits The Test function : checks a single bit to see if it has been set Toggle function : reverses a single bit

48 Anatomy BitArray Fields: 1) Bits: is an array of int each int is capable to store 32 bit or 16 bit. so 128 bits will use 3 cell 2) NumElements: to count how many cells of bits used to store the binary number. 3) Size: used to store number of bits.

49 bits Array of int 32 bit numelements = 5 cells Each cell has 32 bit Number of total bits = 32*5

50 BitArray bits Size : # of bits numelements : # of cells Set ( # of bit ) Reset ( # of bit ) Toggle ( # of bit) Test ( # of bit )

51 Set (int n) X bits OR mask 1 1 << ( n % 32 ) Bits [ n/numbits ] = ( (eletype ) 1 << n % numbits )

52 Reset ( int n ) X bits & AND mask ~ (1<< n % 32 ) Bits [ n/numbits ] & = ~ ) ( eletype ) 1 << n % numbits ) Reset () for ( int i=0; i< numelements; i++ ) bits [ i ] = 0 ;

53 Toggle (int n) X bits ^ mask ~X Bits [ n/numbits ] ^ = ~ (( eletype ) 1 << n % numbits ) Toggle ( ) for ( int i=0; i< numelements ; i++ ) bits [ i ] =~ bits [ i ] ;

54 Test (int n ) X ? bits & mask 0 Nonzero 0 1 int z = Bits [ n/numbits ] & (( eletype ) 1 << n % numbits )

55 BitArray class Example class BitArray private: enum BitPerByte = 8, NumBits = SizeOf(elttype)*BitPerByte} ; size_t size; // maximum number of bits size_t numelements; // size of bits [ ] array elttype * bits; // array of bits } ;

56 Each array component is of type elttype, which we currently define as unsigned int. BitsPerByte determines the number of bits that may be stored in a single byte. NumBits counts the total number of bit positions in each array component, based on the number of bytes in a component, and BitPerByte. Notice that size_t is used throughout the class; this is a standard synonym for unsigned int type.

57 Constructor Bit array constructor has parameter that specifies the number of bit positions in the array. We subtract 1 from this number, divide by NumBits and add 1 to determine the reguired number of array components. BitArray :: BitArray (size_t sz) size = sz ; numelements = ( (size 1) / NumBits) +1 ; bits = new elttype [ numelements] ; Reset ( ) ; }

58 Count Function The count function tests each bit position and return the number of bits that are set. size_t BitArray :: count ( ) const size_t tally =0 ; for ( size_t i=0; i<size; i++) if ( Test (i) ) tally ++ ; } return tally ; }

Calculating Bit Offset Suppose that we want to implement the Test member function, which return 1 if a particlar bit has been set. The array of integers holding the bits is called bits.

59 Calculating Bit Offset Suppose that we want to implement the Test member function, which return 1 if a particlar bit has been set. The array of integers holding the bits is called bits. Let s assume that NumBits equals 8 and we want to locate and test bit n. First we devide n by NumBits to get the array index ( subscript) j that indicate which array element is to be examined un signed j = n / NumBits ;

60 Next we isolate the correct bit by constructing a mask. The expression n % NumBits tells us how many positions to shift 1 to the left align with n s bit position within the current array component. Elttype mask = ( elttype ) 1 << ( n% NumBits ) Next we AND bits [ j ] with the mask and return 1 if the resulting value is not 0. int Z= bits [ j ] & mask return Z!=0

61 Example : Suppose that the array contained the following values and we wanted to check bit 17 : The bits [ ] array NumBits = 8 n = 17 [ 2 ] [ 1 ] [ 0 ] bit 17 J = 17 / 8 = [ 2 ] Mask = 1 << (17 % 8) = 1 << 1 = mask

62 Z = bits [ 2 ] & 2 = 2 // answer : bit 17 is set &

63 Test function The foregoing steps can be folded into a single expression that isolate bit n, and return with its value. int BitArray :: Test ( size_t n) const if ( n>= size ) throw RangeError ( FILE, LINE, n); int z = bits [ n / NumBits ] & ( ( elttype ) 1 << n% NumBits ) ; return Z! =0 ; }

64 Toggle function The toggle function reverses a single bit at position n by XORing it with 1 : void BitArray :: Toggle ( size_t n ) if ( n>= size ) throw RangeError ( FILE, LINE, n); bits [ n / NumBits ] ^ = ( (elttype) 1 << n % NumBits); }

65 Set function The set function sets a single bit at position n void BitArray :: set ( size_t n) if ( n >= size ) throw RangeError ( FILE, LINE, n) ; bits [ n / NumBits ] 1 = ( ( elttype ) 1 << n%numbits) ; }

66 Union operation The = operator is useful for computing the union of two sets. The = operator performs a bitwise OR of each bit in the current array with another array called B2. BitArray & BitArray :: operator = ( const BitArray & B2 ) size count = min ( numelements, B2.numElements ); for ( size_t i=0; i<count ; i++ ) bits [ I ] 1= B2.bits [ I ] ; return *this ; } The min function return the smaller of two unsigned integers.

67 Intersection operation The &= operator is useful computing the intersection two sets. The &= operator performs a bitwise AND of each bit in the current array with another array. BitArray & BitArray :: operator &= ( const BitArray & B2 ) size_t count = min ( numelements, B2.numElements); for ( size_t i=0 ; i< count ; i++ ) bits [ I ] &= B2.bits [ I ] ; return *this; }

68 Stream output operator The stream output operator incorporates the Test operation into translating the bit array with a string of 1 and 0 characters. ostream & operator << ( ostream &os, const BitArray & BA ) for ( size_t i= BA.size ; 0< I ; i++) os<< ( BA.Test (--i)? 1 : 0 ); return os; }

69 Test the BitArray class Main calls several test function, enclosing the calls in a try block. This permits the program to catch the two types of exceptions that can be thrown. int main ( ) try Test1 ( ); Test2 ( ); Test3 ( ); Test4 ( ); } catch ( const RangeError & re ) cout << re ; } catch ( const NoFileError & nf ) cout << nf ; } return 0 ; }

70 void Test1 ( ) Test 1 // Assign along integer to a BitArray object and display the bits. BitArray X(20); X=( ) ; cout << X << \n ; } // Set and reset bit 12 in Bitarray X X.Set (12 ) ; cout<< X << \n ; X.Reset ( 12 ); cout << X << \n ;

71 Test 2 void Test2 ( ) // Read a string of bits from file. ifstream bfile ( bits.txt ); if(! bfile ) throw NoFileError ( bfile ); bfile >> filebits ; cout << filebits << \n ; }

72 Test 3 void Test3 ( ) // Add several integers to a set const size_t setsize = 16 ; BitArray B (SetSize) ; B.Set (1); // Add several elements B.Set (5); B.set (8); B.Set (15); cout<< \n ; << BitArray B: << B << \ n ;

73 // Test for set membership for ( int i=0; i< SetSize ; i++ ) if ( B.Test (1) ) cout<< Setw(2) << I << is a member << \n ; // Perform union and intersection operations BitArray A ( SetSize ); A.Set (3); A.Set (4); A.Set (9); cout<< \n BitArray B : << B ; cout<< \n BitArray A : << A ; A!=B; cout<< \n A union B: << A ; A.Toggle (4); cout << \n Toggled bit 4 : << A << \n ;

74 Test 4 Simulates the scheduling of collage classrooms. We create an array called rooms, and set individual bits matching room that happen to be available. void Test4 ( ) // Create a room scheduling application, and determine which room // are both requested and available. enum -101,-110,-112,-114,-120,-190,-192,200,-201,-205,-208, - 210,-220,-221,-225,-230 } const size_t RoomMax =16 ; BitArray rooms ( RoomMatrix );

75 rooms.set(-101); rooms.set(-110); rooms.set(-120); rooms.set(-220); rooms.set(-221); rooms.set(-225); cout<< \n rooms: <<rooms; // Requests represents requests for available rooms that could be // used for college courses. BitArray reguests (RoomMax); requests.set(-101); requests.set(-110); requests.set(-120); requests.set(-225); requests.set(-230); cout<< \n requests: <<requests;

76 } BitArray approved (RoomMax); approved 1= request ; // Union approved &= rooms ; // Intersection cout<< \n requests approved : << approved << endl;

77 Output

UNIT- 3 Introduction to C++

UNIT- 3 Introduction to C++ C++ Character Sets: Letters A-Z, a-z Digits 0-9 Special Symbols Space + - * / ^ \ ( ) [ ] =!= . $, ; : %! &? _ # = @ White Spaces Blank spaces, horizontal tab, carriage