Arizona s First University. ECE 373. Operation Overloading. The Revolution Operation Will Be Televised (and, these slides will be online later today)

Transcription

1 Arizona s First University. ECE 373 Operation Overloading The Revolution Operation Will Be Televised (and, these slides will be online later today)

2 Previously, on ECE373 Families of operators can be overloaded in C++ Provide a natural look and feel for object behaviors in text Upsides: Easy to read, understand, code, for some operators Downsides Enforcement sometimes made by signature, not always enforceable (we cannot guarantee that subtraction/addition is done correctly) Some contracts made (informally) are not always kept (remember: call your parent function s operator=) Operator [ ] Some operators used in multiple fashions Hard to learn all of the crazy signatures Common uses int array[5]; // Declaring an array array[2] = 10; // Assigning to index int j = array[3]; // Assigning from index 2

3 What s in a signature? retval Class::operator ( const Class& obj ) retval Class::operator ( const Class& obj ) const retval& Class::operator ( const Class& obj ) retval operator ( Class obj ) retval& operator ( Class obj ) 6. const retval& Scope::operator ( ) const These potential signatures are a contract between the interface designer, and the user Consider: example 2 the final const means that the function operator cannot modify the state of the Object the const inside the argument list, means that only const operations can be called on the obj Consider: example 6 the returned const retval object can only receive const operations 3

4 Families of operators Refer to Table 8-1 in the text Ones we will use the most: access: [ ] manipulation: +, -, *, /, ++, --, <<, >>, % bitwise comparison: ^, &,, ~ streaming*: <<, >> assignment: +=, -=, *=, /= unary: ++, --, - comparison in whole: <, >, ==, = * The signature of the function determines the difference between manipulation and streaming 4

5 Starting example: MyInteger // lec17-example1.h #include <cstdio> #include <sstream> class MyInteger { public: MyInteger( int i=0 ) : value( i ) { } ~MyInteger( ) { } MyInteger( const MyInteger& other ) : value( other.value ) { } MyInteger& operator=( const MyInteger& other ) { value = other.value; } std::string tostring( ) { std::stringstream result; result << value; return result.str( ); } protected: int value; }; // lec17-example1.cpp #include "lec17-example1.h" #include <iostream> int main( void ) { MyInteger a,b(10); std::cout << "a=" << a.tostring( ) << std::endl; std::cout << "b=" << b.tostring( ) << std::endl; a=b; std::cout << "a=" << a.tostring( ) << std::endl; std::cout << "b=" << b.tostring( ) << std::endl; return EXIT_SUCCESS; } 1. Does it compile? 2. What s the result??? 5

6 Example 1: results Scanning dependencies of target lec17-example1 [ 93%] Building CXX object src/lectures/lec17/cmakefiles/lec17-example1.dir/lec17-example1.cpp.o Linking CXX executable lec17-example1 macphee-2:build sprinkle$./src/lectures/lec17/lec17-example1 a=0 b=10 a=10 b=10 macphee-2:build sprinkle$ 6

7 Example 2: Twist // lec17-example2.h #include <cstdio> #include <sstream> class MyInteger { public: MyInteger( int i=0 ) : value( i ) { } ~MyInteger( ) { } MyInteger( const MyInteger& other ) : value( other.value ) { } MyInteger& operator=( const MyInteger& other ) { value = other.value; } std::string tostring( ) { std::stringstream result; result << value; return result.str( ); } protected: int value; }; // lec17-example2.cpp #include "lec17-example2.h" #include <iostream> int main( void ) { MyInteger a,b(10); std::cout << "a=" << a.tostring( ) << std::endl; std::cout << "b=" << b.tostring( ) << std::endl; //a=b; a=7; std::cout << "a=" << a.tostring( ) << std::endl; std::cout << "b=" << b.tostring( ) << std::endl; return EXIT_SUCCESS; } 1. Does it compile? 2. What s the result??? 7

8 Ha Ha Scanning dependencies of target lec17-example2 [ 94%] Building CXX object src/lectures/lec17/cmakefiles/lec17-example2.dir/lec17-example2.cpp.o Linking CXX executable lec17-example2 macphee-2:build sprinkle$./src/lectures/lec17/lec17-example2 a=0 b=10 a=7 b=10 macphee-2:build sprinkle$ 8

9 Why does it compile? Conversion constructors are constructors that can be called with a single argument. It specified a conversion from the type of its first argument to the type of its class (i.e., the class to which the constructor belongs). // the MyInteger is created by the // compiler as a temporary object a = MyInteger(7); The conversion is applied implicitly when the compiler deems it is needed unless the explicit modifier is used when declaring the constructor. class MyInteger { public: explicit MyInteger( int i=0 ) : value( i ) { }... } 9

10 Example 3: Explicit Constructors // lec17-example3.h #include <cstdio> #include <sstream> class MyInteger { public: explicit MyInteger( int i=0 ) : value( i ) { } ~MyInteger( ) { } MyInteger( const MyInteger& other ) : value( other.value ) { } MyInteger& operator=( const MyInteger& other ) { value = other.value; } std::string tostring( ) { std::stringstream result; result << value; return result.str( ); } protected: int value; }; // lec17-example3.cpp #include "lec17-example3.h" #include <iostream> int main( void ) { MyInteger a,b(10); std::cout << "a=" << a.tostring( ) << std::endl; std::cout << "b=" << b.tostring( ) << std::endl; b = MyInteger(7); a=b; a=7; std::cout << "a=" << a.tostring( ) << std::endl; std::cout << "b=" << b.tostring( ) << std::endl; return EXIT_SUCCESS; } 1. Does it compile? 2. What s the result??? 10

11 Scanning dependencies of target lec17-example3 [ 94%] Building CXX object src/lectures/lec17/cmakefiles/lec17-example3.dir/lec17-example3.cpp.o /Users/sprinkle/work/teaching/ece373/src/lectures/lec17/lec17-example3.cpp: In function int main() : /Users/sprinkle/work/teaching/ece373/src/lectures/lec17/lec17-example3.cpp:18: error: no match for operator= in a = 7 /Users/sprinkle/work/teaching/ece373/src/lectures/lec17/lec17-example3.h:12: note: candidates are: MyInteger& MyInteger::operator=(const MyInteger&) make[2]: *** [src/lectures/lec17/cmakefiles/lec17-example3.dir/lec17-example3.cpp.o] Error 1 make[1]: *** [src/lectures/lec17/cmakefiles/lec17-example3.dir/all] Error 2 make: *** [all] Error 2 macphee-2:build sprinkle$ Of course, we could fix even this by defining MyInteger& operator=( int other ) { value = other; } Use explicit as a keyword, if you want to prevent conversion construction (e.g., if the compiler has an error in that there are two potential operations that conflict) 11

12 Starting with the operators // lec17-example4.h #include <cstdio> #include <sstream> class MyInteger { public: MyInteger( int i=0 ) : value( i ) { } ~MyInteger( ) { } MyInteger( const MyInteger& other ) : value( other.value ) { } MyInteger& operator=( const MyInteger& other ) { value = other.value; } std::string tostring( ) { std::stringstream result; result << value; return result.str( ); } // add two MyIntegers together MyInteger operator+( const MyInteger& rhs ) { MyInteger result; result.value = rhs.value + value; return result; } protected: int value; }; // lec17-example4.cpp #include "lec17-example4.h" #include <iostream> int main( void ) { MyInteger a,b(10); std::cout << "a=" << a.tostring( ) << std::endl; std::cout << "b=" << b.tostring( ) << std::endl; MyInteger c; c = a+b; std::cout << "c=" << c.tostring( ) << std::endl; return EXIT_SUCCESS; } 1. Does it compile? 2. What s the result??? 12

13 Scanning dependencies of target lec17-example4 [100%] Building CXX object src/lectures/lec17/cmakefiles/lec17-example4.dir/lec17-example4.cpp.o Linking CXX executable lec17-example4 [100%] Built target lec17-example4 macphee-2:build sprinkle$./src/lectures/lec17/lec17-example4 a=0 b=10 c=10 macphee-2:build sprinkle$ 13

14 Do the twist // lec17-example5.h #include <cstdio> #include <sstream> class MyInteger { public: MyInteger( int i=0 ) : value( i ) { } ~MyInteger( ) { } MyInteger( const MyInteger& other ) : value( other.value ) { } MyInteger& operator=( const MyInteger& other ) { value = other.value; } std::string tostring( ) { std::stringstream result; result << value; return result.str( ); } // add two MyIntegers together MyInteger operator+( const MyInteger& rhs ) { MyInteger result; result.value = rhs.value + value; return result; } protected: int value; }; 1. Does it compile? 2. What s the result??? // lec17-example5.cpp #include "lec17-example5.h" #include <iostream> int main( void ) { MyInteger a,b(10); std::cout << "a=" << a.tostring( ) << std::endl; std::cout << "b=" << b.tostring( ) << std::endl; MyInteger c,d; a = b + 7; // option 1 std::cout << "a=" << a.tostring( ) << std::endl; c = 10 + a; // option 2 std::cout << "c=" << c.tostring( ) << std::endl; d = ; // option 3 std::cout << "d=" << d.tostring( ) << std::endl; return EXIT_SUCCESS; } 14

15 Example 5: Result Scanning dependencies of target lec17-example5 [100%] Building CXX object src/lectures/lec17/cmakefiles/lec17-example5.dir/lec17-example5.cpp.o /Users/sprinkle/work/teaching/ece373/src/lectures/lec17/lec17-example5.cpp: In function int main() : /Users/sprinkle/work/teaching/ece373/src/lectures/lec17/lec17-example5.cpp:20: error: no match for operator+ in 10 + a make[2]: *** [src/lectures/lec17/cmakefiles/lec17-example5.dir/lec17-example5.cpp.o] Error 1 make[2]: Target `src/lectures/lec17/cmakefiles/lec17-example5.dir/build' not remade because of errors. make[1]: *** [src/lectures/lec17/cmakefiles/lec17-example5.dir/all] Error 2 make[1]: Target `all' not remade because of errors. make: *** [all] Error 2 make: Target `default_target' not remade because of errors. 15

16 What s the problem? The compiler isn t smart enough to call a conversion constructor on 10, because there is such a huge number of things that take int objects as constructors Conversion constructors really only work when they are called with an L-value // example L-value calls a = b + 7; // -> a.operator=( b.operator+( 7 ) ) d = ; // -> d.operator=( MyInteger( 10+7 ) ) // example NON L-value calls c = 10 + a; // -> c.operator=( 10 + a );???? So, not all operators are class members, some are global functions that are declared as friend functions We discuss next, which ones, and why... 16

17 Operators as class members CLASS &operator=(const CLASS &src); CLASS &operator&=(const CLASS &src); CLASS &operator =(const CLASS &src); CLASS &operator^=(const CLASS &src); CLASS &operator+=(const CLASS &src); CLASS &operator-=(const CLASS &src); CLASS &operator*=(const CLASS &src); CLASS &operator++(void);//prefix operator Need to use our state Logically take a right-hand side as an argument Do not (always) have to return by reference: CLASS operator++(int);//postfix operator CLASS operator-(void) const; Any operator that REQUIRES an l-value is better implemented as a member function. This shows that it can ONLY be invoked on existing, modifiable, objects. 17

18 The pre/postfix operator Remember these good times? #include <cstdio> #include <iostream> int main( void ) { std::cout << "Postfix ============" << std::endl; for( int i=0; i<10; i++ ) { std::cout << "in, i=" << i++ << std::endl; } } std::cout << "Prefix ============" << std::endl; for( int i=0; i<10; i++ ) { std::cout << "in, i=" << ++i << std::endl; } Postfix ============ in, i=0 in, i=2 in, i=4 in, i=6 in, i=8 Prefix ============ in, i=1 in, i=3 in, i=5 in, i=7 in, i=9 18

19 Pre/Post So, why the difference in the two signatures, anyway? CLASS &operator++(void);//prefix operator CLASS operator++(int);//postfix operator The postfix operator returns the current value, and in the meantime, we change our state. The prefix operator returns the new value, and simultaneously changes our state. So, THIS doesn t make sense, right? CLASS &operator++(void) const;//prefix operator CLASS operator++(int) const;//postfix operator 19

20 Ways to remember (some) semantics Pre/post (just showed): Remember which one changes state NOW Negate: does not change state...you need to say x = -x, and you do not need any kind of parameter value CLASS operator-(void) const; ALL assignment operators return this* (duh...), and do not need to change the state of what is passed in CLASS &operator=(const CLASS &src); CLASS &operator&=(const CLASS &src); CLASS &operator =(const CLASS &src); CLASS &operator^=(const CLASS &src); CLASS &operator+=(const CLASS &src); CLASS &operator-=(const CLASS &src); CLASS &operator*=(const CLASS &src); 20

21 Operators as friend functions friend CLASS operator (const CLASS &lhs, const CLASS &rhs); friend CLASS operator&(const CLASS &lhs, const CLASS &rhs); friend CLASS operator^(const CLASS &lhs, const CLASS &rhs); friend bool operator==(const CLASS &lhs, const CLASS &rhs); friend bool operator=(const CLASS &lhs, const CLASS &rhs); friend bool operator>(const CLASS &lhs, const CLASS &rhs); friend bool operator<(const CLASS &lhs, const CLASS &rhs); friend CLASS operator~(const CLASS &src); friend CLASS operator*(const CLASS &lhs, const CLASS &rhs); friend CLASS operator+(const CLASS &lhs, const CLASS &rhs); friend CLASS operator-(const CLASS &lhs, const CLASS &rhs); friend CLASS operator<<(const CLASS &lhs, unsigned int n_bits); friend CLASS operator>>(const CLASS &lhs, unsigned int n_bits); friend ostream &operator<<(ostream &out, const CLASS &src); friend istream &operator<<(istream &in, CLASS &dst); Why do these need to be FRIEND functions? y = x; 21

22 Friend function operators Use conversion constructors to find an appropriate operator overload to perform the operation You don t know which argument will be converted, so you create a non-member function that can be called by the compiler, and make it your friend, so it can play with your, uh, I mean, use your parts. Conversion constructors Create a class from another data type (int, etc.) Useful for things like y = x Any operator that does not require an l-value and is commutative is better implemented as a non-member function (+,-, etc.). This allows the compiler to apply a conversion in case of argument mismatch for the first argument. 22

23 A final note on conversions // lec17-example6.cpp #include "lec17-example6.h" #include <iostream> int main( void ) { MyInteger a,b(10); std::cout << "a=" << a.tostring( ) << std::endl; std::cout << "b=" << b.tostring( ) << std::endl; int j; // what happens here? j = b; return EXIT_SUCCESS; } 23

24 Conversion functions // lec17-example6.h #include <cstdio> #include <sstream> class MyInteger { public: MyInteger( int i=0 ) : value( i ) { } ~MyInteger( ) { } MyInteger( const MyInteger& other ) : value( other.value ) { } MyInteger& operator=( const MyInteger& other ) { value = other.value; } std::string tostring( ) { std::stringstream result; result << value; return result.str( ); } // converts this class into an int operator int( ) { return value; } protected: int value; }; // lec17-example6.cpp #include "lec17-example6.h" #include <iostream> int main( void ) { MyInteger a,b(10); std::cout << "a=" << a.tostring( ) << std::endl; std::cout << "b=" << b.tostring( ) << std::endl; int j; // what happens here? j = b; return EXIT_SUCCESS; } 24

25 Example 6: Results Scanning dependencies of target lec17-example6 [100%] Building CXX object src/lectures/lec17/cmakefiles/lec17-example6.dir/lec17-example6.cpp.o Linking CXX executable lec17-example6 [100%] Built target lec17-example6 macphee-2:build sprinkle$./src/lectures/lec17/lec17-example6 a=0 b=10 j=10 macphee-2:build sprinkle$ 25

26 Overloading stream operators (<<) // lec17-example7.h #include <cstdio> #include <sstream> class MyInteger { public: MyInteger( int i=0 ) : value( i ) { } ~MyInteger( ) { } MyInteger( const MyInteger& other ) : value( other.value ) { } MyInteger& operator=( const MyInteger& other ) { value = other.value; } std::ostream &operator<<( std::ostream& out, const MyInteger& rhs ) { out << rhs.value; return out; } // converts this class into an int operator int( ) { return value; } protected: int value; }; // lec17-example7.cpp #include "lec17-example7.h" #include <iostream> int main( void ) { MyInteger a,b(10); std::cout << "a=" << a << std::endl; std::cout << "b=" << b << std::endl; int j; // what happens here? j = b; std::cout << "j=" << j << std::endl; return EXIT_SUCCESS; } 26

27 Uh oh, what did we do wrong? Scanning dependencies of target lec17-example7 [100%] Building CXX object src/lectures/lec17/cmakefiles/lec17-example7.dir/lec17-example7.cpp.o In file included from /Users/sprinkle/work/teaching/ece373/src/lectures/lec17/lec17-example7.cpp:3: /Users/sprinkle/work/teaching/ece373/src/lectures/lec17/lec17-example7.h:17: error: std::ostream& MyInteger::operator<<(std::ostream&, const MyInteger&) must take exactly one argument make[2]: *** [src/lectures/lec17/cmakefiles/lec17-example7.dir/lec17-example7.cpp.o] Error 1 make[1]: *** [src/lectures/lec17/cmakefiles/lec17-example7.dir/all] Error 2 make: *** [all] Error 2 friend ostream &operator<<(ostream &out, const CLASS &src); Ah, right...yeah, there s a reason to pay attention to that kind of stuff. 27

28 Example 8: operator<< done right // lec17-example8.h #include <cstdio> #include <sstream> class MyInteger { public: MyInteger( int i=0 ) : value( i ) { } ~MyInteger( ) { } MyInteger( const MyInteger& other ) : value( other.value ) { } MyInteger& operator=( const MyInteger& other ) { value = other.value; } friend std::ostream &operator<<( std::ostream& out, const MyInteger& rhs ) { out << rhs.value; return out; } // converts this class into an int operator int( ) { return value; } protected: int value; }; // lec17-example8.cpp #include "lec17-example8.h" #include <iostream> int main( void ) { MyInteger a,b(10); std::cout << "a=" << a << std::endl; std::cout << "b=" << b << std::endl; int j; // what happens here? j = b; std::cout << "j=" << j << std::endl; return EXIT_SUCCESS; } 28

29 Example 8: Results [100%] Building CXX object src/lectures/lec17/cmakefiles/lec17-example8.dir/lec17-example8.cpp.o Linking CXX executable lec17-example8 [100%] Built target lec17-example8 macphee-2:build sprinkle$./src/lectures/lec17/lec17-example8 a=0 b=10 j=10 macphee-2:build sprinkle$ 29