Overloading Operators in C++

Transcription

1 Overloading Operators in C++ C++ allows the programmer to redefine the function of most built-in operators on a class-by-class basis the operator keyword is used to declare a function that specifies what an operator symbol (such as = or +) means when it is applied to instances of a class this gives the operator more than one meaning, and the compiler determines what meaning is intended by looking at the types of its operands syntax: type operator <operator-symbol> (parameter-list) Example: overloading the addition operator and the assignment operator for a class Complex that is intended to represent complex numbers

2 Example Class to represent complex numbers: header (class definition file) #pragma once #include <iostream> using namespace System; using namespace std; class Complex { public: Complex (); Complex (double r, double i); Complex operator+ (Complex &other); Complex & Complex::operator = (Complex &n); void display(); private: double re,im; ;

3 .cpp source (implementation) file for for class Complex #include "stdafx.h" #include " Complex.h" Complex::Complex (){ re = 0.0; im = 0.0; Complex::Complex(double r, double i){ re = r; im = i; Overloaded addition operator Complex Complex::operator + (Complex &other){ return Complex (re + other.re, im + other.im); Complex & Complex::operator = (Complex &n){ re = n.re; im = n.im; return *this; Overloaded assignment operator void Complex::display(){ cout << re << "," << im << endl;

4 Example of a small program using class Complex: #include "stdafx.h" #include <iostream> #include "Complex.h" using namespace System; using namespace std; int main(array<system::string ^> ^args) { Complex a = Complex(1.2, 3.4); Complex b(3.4, 5.6); Complex c; c = a + b; c.display(); return 0;

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

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

7 Let s look carefully at the overloading of the + operator: Complex Complex::operator + (Complex &other) { return Complex (re + other.re, im + other.im) this defines a function that tells what the + operator does when it is applied to instances of class Complex this is also a method of class Complex, so one of its operands (the left operand) is an object of class Complex to which the method is being applied the other operand (the right operand) is another object of class Complex the method returns an object of type Complex with data members that are the sums of the real and imaginary parts of the other two operands Usage: a + b Here a == (re_a, im_a) and b == (re_b, im_b) and the returned object is a complex number (re_a + re_b, im_a+im_b)

8 Overloading the Assignment Operator The assignment operator (=) is really a binary operator it has two arguments: its left side and its right side in the expression x = 5 + 3; we expect to evaluate the right side and give that value to the thing on the left side (in this case, the int variable x) If we are going to build a Complex class, we will need to have some operator that allows us to assign values to objects of this class this means that we might want to overload the = operator

9 Overloaded Assignment Operator for the Complex class: // overloading of the assignment operator = Complex & Complex::operator = (Complex &n){ re = n.re; im = n.im; return *this; remember that if this assignment operator is in use, it is because the target object (i.e. the left operand) has invoked the operator to provide values for the target s data members the return type has to be a reference to an object of type Complex (that is, the target object) the source of the values has to be an object of type Complex, so the (right) argument to the operator has to be of that type the return value is *this Remember -- C++ defines the keyword this to have a value that is the address of the object whose member function is being invoked Using the dereferencing operator * makes the thing that is returned be the object whose member function is being invoked

10 Issues with Overloading the Assignment Operator The assignment operator is a binary operator, and its declaration is the same as any other binary operator with the following exceptions: It has to be a nonstatic member function. You cannot declare operator= as a nonmember function. the overloaded assignment operator is not inherited by any derived classes (we ll touch on this again soon) a default overloaded assignment operator can be generated by the compiler if none exists, but be aware: the default assignment operator uses memberwise assignment, which is not what we want when a class has const members a class has reference members a class or its base class has its own defined assignment operator a base class or member class has no assignment operator in these cases, we have to define appropriate assignment operators if we need to do assignment

11 Overloading << We might want to overload the stream extraction operator << and the string insertion operator >> It s easy to do, but there is a small wrinkle Because these operators might get called without instantiating an object, it is important to make them be friends of the class instead of members of the class A friend function (or operator) of a class is a function that can access private members of the class How to do this? In the class definition, you declare the operator a friend of the class You put the definition of the operator with the class implementation

12 Overloading << and >> for class Complex class Complex { friend ostream & operator<<(ostream &out, const Complex c); friend istream & operator>>(istream &in, Complex &c); public: Complex (); Complex (double r, double i); Complex operator+ (Complex &other); Complex & Complex::operator = (Complex &n); double getre(); double getim(); void display(); private: double re,im; ; Complex Complex::operator + (Complex & c) { return Complex (re + c.re, im + c.im) ostream & operator << (ostream &out, const Complex c) //output { out<<"real part: " << c.re <<" imag part: "<< c.im <<"\n"; return out; istream & operator >> (istream &in, Complex &c) { cout<<"enter real part:\n"; in>>c.re; cout<<"enter imag part: \n"; in>>c.im; return in; //input

13 Overloading == Comparing objects is something we want to do all the time. This operator is one that is intended to compare two objects of the same type and return true if they are the same and false otherwise. But what do we mean by "the same"? You decide what will constitute equality in class members When you create your own classes, you choose whether equivalency means that every data field must be equivalent, or only specific data members

14 Overloading == an example bool Complex::operator == (const Complex &other) { bool b; b = (re == other.re) && (im == other.im); return (b) This is fine when data members are simple. BUT - If, for example, we have a class, where we have a data member that is a dynamic array of int's member and an int data member that is the array's size, it may not be so simple.

15 class mydata{ public: mydata(); mydata (const int size); bool operator == (const mydata &); // More methods will be needed as well here private: int *data; int size; ; Overloading == another example mydata::mydata() { size = 5; data = new int[size]; mydata::mydata(const int s) { data = new int[s]; size = s; bool mydata::operator == (const mydata &other) { // What do you want here? return (??);

16 Guidelines for Overloading Operators Suppose we are overloading the symbol # for some class MyClass: left # right We have 2 choices: we could make the operator # function a member of MyClass or we could make it a non-member function. If left is of type MyClass, we normally make it a member function: returntype MyClass::operator # (righttype right) {... Note that left is the implicit object in this case the one that is calling the operator Examples: a+b x && y x1 == y1 If left is not of type MyClass, you can make it a non-member function returntype operator # (lefttype left, righttype right) {... And if it needs access to private data members, make it a friend Examples: cout << a cin >> x If the return value will overwrite the value of left, then make it send back the reference: returntype & operator # (lefttype left, righttype right) {... Examples: x += y a *= b 16