G52CPP C++ Programming Lecture 18. Dr Jason Atkin

Transcription

1 G52CPP C++ Programming Lecture 18 Dr Jason Atkin 1

2 Last lecture Operator Overloading Strings and streams 2

3 Operator overloading - what to know Know that you can change the meaning of operators Know that operator overloading is available as both a member function version and a global (non-member) function version Be able to provide the code for the overloading of an operator Parameter types, const? Return type Simple implementations 3

4 Questions to ask yourself Define as a member or as a global? If global then does it need to be a friend? What should the parameter types be? References? Make them const if you can What should the return type be? Should it return *this? Does it need to return a copy of the object? e.g. post-increment must return a copy Should the function be const? 4

5 My string comparison operator bool operator==( const std::string& s1, const std::string& s2) return 0 == strcmp( s1.c_str(), s2.c_str() ); } Get the string as a char array int main () string str1( "Same" ); string str2( "Same" ); string str3( "Diff" ); printf( "str1 and str2 are %s\n", (str1 == str2)? "Same" : "Diff" ); printf( "str1 and str3 are %s\n", (str1 == str3)? "Same" : "Diff" ); printf( "str2 and str3 are %s\n", (str2 == str3)? "Same" : "Diff" ); } 5

6 streams for input/output C++ input/output classes use streams Three standard stream objects exist already istream cin; (matches stdin) ostream cout; (matches stdout) ostream cerr; (matches stderr) Header file includes the declarations: #include <iostream> They are in std namespace Use std::cin, std::cout, etc >> and << operators are overloaded for input and output endl sent to a stream will output \n and flush 6

7 Example of output #include <iostream> using namespace std; Look in std namespace for the names which follow int main() e.g. cin, cout, cerr const char* str = "Test string"; int i = 1; Overloaded operator - input cin >> i; cout << str << " " << i << endl; cerr << str << endl; Header file for input AND output Overloaded operator - output } return 0; 7

8 This lecture Template functions Template Classes Slicing Problem 8

9 Function Overloading We can use function overloading to have multiple versions of the same function Consider the following functions: int mymax( int a, int b ) return a > b? a : b; } float mymax( float a, float b ) return a > b? a : b; } char mymax( char a, char b ) return a > b? a : b; } It would be nice to create just the one 9

10 Template version int mymax( int a, int b ) return a > b? a : b; } float mymax( float a, float b ) return a > b? a : b; } char mymax( char a, char b ) return a > b? a : b; } template < typename T > T mymax( T a, T b ) return a > b? a : b; } 10

11 Template functions Templates specify how to create functions of a certain format, if they are ever needed, e.g.: template < typename T > T mymax( T a, T b ) return a > b? a : b; } Note: you can use keyword class or typename : i.e. template < class T > Type placeholders are used, and are replaced implicitly Could use it as any type, e.g.: int i1 = 4, i2 = 14; int i3 = mymax( i1, i2 ); 11

12 What templates do The compiler will actually generate the functions which are needed, according to the parameters i.e. at compile time, new functions are created If there are any problems, it will not compile e.g. if new template class needs a function or operator which is not supported by the type This is NOT something done at runtime 12

13 Example for mymax #include <iostream> using namespace std; template < typename T > T mymax( T a, T b ) return a > b? a : b; } So that compiler knows what cout is when we use it later (and what endl is) int main() int i1 = 4, i2 = 14; int i3 = mymax( i1, i2 ); cout << "mymax(" << i1 << "," << 12 << ") = " << i3 << endl; } 13

14 Compiler generates a function #include <iostream> using namespace std; template < typename T > T mymax( T a, T b ) return a > b? a : b; } int mymax( int a, int b ) int main() return a > b? a : b; } int i1 = 4, i2 = 14; int i3 = mymax( i1, i2 ); cout << "mymax(" << i1 << "," << 12 << ") = " << i3 << endl; 14 }

15 How to create template functions The easy way to create these template functions: First manually generate a function for specific types Next replace all copies of the types by an identifier Then add the keyword template at the beginning and put the type(s) in the <> with keyword typename (or class) For example, an addition with casting function: int addcast( int a, float b ) return a + static_cast<int>(b); } Becomes: template <typename T1, typename T2> T1 addcast( T1 a, T2 b ) return a + static_cast<t1>(b); } And can be used as: int val = addcast( 12, 4.65 ); 15

16 Example of addcast<t1,t2> #include <iostream> // cout using namespace std; template <typename T1, typename T2> T1 addcast( T1 a, T2 b ) return a + static_cast<t1>(b); } Creates a version which changes the float to an int and adds them int main() int val = addcast( 12, 4.65 ); cout << 12 << "+" << 4.65 << "=" << val << endl; } return 0; 16

17 Question: Will this compile? #include <iostream> using namespace std; template <typename T1, typename T2> T1 addcast( T1 a, T2 b ) return a + static_cast<t1>(b); } class MyFloat public: MyFloat( float f ) : f(f) } float f; }; Code in main: MyFloat f1(1.1); float f2 = 2.2; MyFloat f3 = addcast(f1,f2); cout << f3.f << endl; 17

18 The compilation error template <typename T1, typename T2> T1 addcast( T1 a, T2 b ) return a + static_cast<t1>(b); } class MyFloat public: MyFloat( float f ) : f(f) } MyFloat f1(1.1); float f2 = 2.2; MyFloat f3 = addcast(f1,f2); cout << f3.f << endl; template1.cpp: In function T1 addcast(t1, T2) float f; [with T1 = MyFloat, T2 = float] : }; template1.cpp:32:28: instantiated from here template1.cpp:7:31: error: no match for operator+ in a + MyFloat(b) 18

19 Add an operator+ template <typename T1, typename T2> T1 addcast( T1 a, T2 b ) return a + static_cast<t1>(b); } class MyFloat public: MyFloat( float f ) : f(f) } MyFloat f1(1.1); float f2 = 2.2; MyFloat f3 = addcast(f1,f2); cout << f3.f << endl; MyFloat float operator+( f; const MyFloat& f1, const MyFloat& f2) }; MyFloat f( f1.f + f2.f ); return f; } 19

20 Template classes 20

21 Template class You can make template forms of entire classes as well as individual functions Again the typename placeholder name (e.g. T) is replaced throughout the class You need to use it in both the class declaration and the member function implementations To alter class definition: Add template <typename T> at the start, as for template functions Then replace the templated type throughout the code 21

22 Template class : linked list class MyLinkedList struct Entry struct Entry* pnext; int idata; }; Entry* _phead; public: MyLinkedList() : _phead(null) } void InsertHead( int idata ); template < typename T > class MyLinkedList struct Entry struct Entry* pnext; T tdata; }; Entry* _phead; public: MyLinkedList() : _phead(null) } void InsertHead( T tdata ); }; void List(); }; void List(); 22

23 How to alter member functions Add prior to each member function definition: template <typename T> Add the <T> to the end of the class name in the member function implementation/definition: Example member function implementation: template <typename T> void MyLinkedList<T>::Store(T tdata) } Find each occurrence of the templated type and replace it by the templated type name e.g. replace int with T in the example Note: typename can be replaced by class 23

24 The member functions void MyLinkedList:: InsertHead(int idata) Entry* pnewentry = new Entry(); pnewentry->idata = idata; pnewentry->pnext = _phead; _phead = pnewentry; } void MyLinkedList::List() Entry* pentry = _phead; while( pentry!= NULL ) cout << pentry->idata << endl; pentry = pentry->pnext; } } template <typename T> void MyLinkedList<T>:: InsertHead(T tdata) Entry* pnewentry = new Entry(); pnewentry->tdata = tdata; pnewentry->pnext = _phead; _phead = pnewentry; } template <typename T> void MyLinkedList<T>::List() Entry* pentry = _phead; while( pentry!= NULL ) cout << pentry->tdata << endl; pentry = pentry->pnext; } } 24

25 Using the template class int test1() MyLinkedList<float> olist; olist.inserthead( 1.1 ); olist.inserthead( 2.2 ); olist.inserthead( 3.3 ); olist.inserthead( 4.4 ); olist.inserthead( 5.5 ); olist.inserthead( 6.6 ); olist.list(); } int test2() MyLinkedList<string> olist; olist.inserthead( "Adam" ); olist.inserthead( "Brian" ); olist.inserthead( "Carl" ); olist.inserthead( "Dave" ); olist.inserthead( "Eric" ); olist.inserthead( "Fred" ); // Following line would not compile: //olist.inserthead( 1.2 ); olist.list(); } The class name is qualified with a type in angled brackets. Once specified, the type is fixed. Instantiations of the class are generated by the compiler as needed. 25

26 Exam: do I need to know all of this? Template functions Be able to recognise them Know what they do Be able to convert from a normal function to a template version Know the difference between a template function and a macro (#define) And the dangers of using #define Template classes Recognise them Be able to understand code which uses them Understand code using STL classes 26

27 ReminderL STL container classes vector string map list set stack queue deque multimap multiset In std namespace Know that Standard Template Library exists If you go for C++ job interview, learn basics These are template classes e.g. vector<int> for vector of ints Also have iterators Track position/index in a container e.g. to iterate through a container And algorithms (over 70 of them) Apply to containers e.g. min(), max(), sort(), search() 27

28 Dangers of arrays And of STL containers Same problems apply 28

29 Example of using vector #include <iostream> #include <string> #include <vector> using namespace std; int main() vector<char> v(10); // 10 elements int size = v.size(); cout << "Size " << size << endl; } // Set each value for( int i=0 ; i < size ; i++ ) v[i] = i; // Iterate through vector vector<char>::iterator p = v.begin(); for( ; p!= v.end() ; p++ ) *p += 97; // Output the contents for( int i=0 ; i < size ; i++ ) cout << v[i] << endl; return 0; 29

30 Arrays of pointers #include <iostream> using namespace std; class Base public: Base() : i(1) } virtual void out() cout <<"Base" <<i <<endl; } int i; }; class Sub : public Base public: Sub() i = 2; } void out() cout <<"Sub" <<i <<endl; } }; Lec18a.cpp int main() Sub* arrayp1[3] = new Sub, new Sub, new Sub }; Base* arrayp2[3] = new Base, new Base, new Base }; // Output Array 1 for ( int i = 0 ; i < 3 ; i++ ) arrayp1[i]->out(); // Output Array 2 for ( int i = 0 ; i < 3 ; i++ ) arrayp2[i]->out(); // Copy Array 1 elements to 2 for ( int i = 0 ; i < 3 ; i++ ) arrayp2[i] = arrayp1[i]; // Output Array 2 for ( int i = 0 ; i < 3 ; i++ ) arrayp2[i]->out(); } 30

31 Arrays of pointers #include <iostream> using namespace std; class Base public: Base() : i(1) } virtual void out() cout <<"Base" <<i <<endl; } int i; }; class Sub : public Base public: Sub() i = 2; } void out() cout <<"Sub" <<i <<endl; } }; Lec18a.cpp int main() Sub* arrayp1[3] = new Sub, new Sub, new Sub }; Base* arrayp2[3] = new Base, new Base, new Base }; // Output Array 1 for ( int i = 0 ; i < 3 ; i++ ) Call out() on each object in arrayp1 arrayp1[i]->out(); // Output Array 2 for ( int i = 0 ; i < 3 ; i++ ) Call out() on each object in arrayp2 arrayp2[i]->out(); // Copy Array 1 elements to 2 for ( int i = 0 ; i < 3 ; i++ ) Copy subclass pointers to Base* array arrayp2[i] = arrayp1[i]; // Output Array 2 for ( int i = 0 ; i < 3 ; i++ ) Call out() on each object in arrayp2 i.e. the arrayp2[i]->out(); Base* array, with Sub* objects } 31

32 Objects are not pointers #include <iostream> using namespace std; class Base public: Base() : i(1) } virtual void out() cout <<"Base" <<i <<endl; } int i; }; class Sub : public Base public: Sub() i = 2; } void out() cout <<"Sub" <<i <<endl; } }; Lec18b.cpp int main() Sub array1[3]; Base array2[3]; // Output Array 1 Arrays of objects for ( int i = 0 ; i < 3 ; i++ ) array1[i].out(); // Output Array 2 for ( int i = 0 ; i < 3 ; i++ ) array2[i].out(); // Copy array 1 to 2 for ( int i = 0 ; i < 3 ; i++ ) array2[i] = array1[i]; // Output Array 2 for ( int i = 0 ; i < 3 ; i++ ) array2[i].out(); } 32

33 Objects are not pointers #include <iostream> using namespace std; class Base public: Base() : i(1) } virtual void out() cout <<"Base" <<i <<endl; } int i; }; class Sub : public Base public: Sub() i = 2; } void out() cout <<"Sub" <<i <<endl; } }; Lec18b.cpp int main() Sub array1[3]; Base array2[3]; // Output Array 1 for ( int i = 0 ; i < 3 ; i++ ) array1[i].out(); // Output Array 2 for ( int i = 0 ; i < 3 ; i++ ) array2[i].out(); // Copy array 1 to 2 for ( int i = 0 ; i < 3 ; i++ ) array2[i] = array1[i]; Arrays of objects Call out() on each object in arrayp1 Call out() on each object in arrayp2 Copy subclass OBJECTS to Base array // Output Array 2 for Call ( out() int on i = each 0 ; object i < 3 in ; array2 i++ ) i.e. array2[i].out(); the Base array, after Sub copy } 33

34 The slicing problem In that example, we stored base class objects So when we tried to assign sub-class objects only the base class part was stored We sliced off the sub-class part This may be obvious, but things can get worse 34

35 What is the slicing problem? Passing an object type parameter by value uses the copy constructor i.e. copies it Assigning an object to another object copies the values, using the assignment operator If the thing you are copying to is a base class object (or thinks it is!) the base class assignment operator is used Neither the default copy constructor nor assignment operator are virtual The base class version gets used!!! Just making them virtual would not help anyway see lecture 20 The slicing problem occurs when you treat a sub-class as the base class for a copy/assignment Only the base class parts get copied i.e. the sub-class parts are sliced off 35

36 How can it happen? By using references or pointers, e.g.: class BaseClass int main() public: SubClass s1, s2; int MyParam; }; BaseClass& rs1 = s1; BaseClass& rs2 = s2; class SubClass rs1 = rs2; : public BaseClass BaseClass* ps1 = &s1; public: BaseClass* ps2 = &s2; int MySubClassParam; *ps1 = *ps2; }; } The sub-class part will not be copied 36

37 Why? The slicing problem occurs when you treat a sub-class as the base class for a copy/assignment Only the base class parts get copied i.e. the sub-class parts are sliced off A function like this was created and used: Base& operator=(const Base& rhs ) } this->myparam = rhs.myparam; return *this; Rather than using the sub-class version: SubClass& operator=(const SubClass& rhs ) this->mysubclassparam = rhs.mysubclassparam; } this->myparam = rhs.myparam; return *this; 37

38 This week and beyond Tuesday 9am, some templates, operator overloads, etc Plus any questions, coursework or otherwise? Friday 28 th March, Lecture 19 When is a duck an instrument? (Multiple Inheritance) And the SET/SEM assessment for last 1/3 of lecture Monday 31 st March: Lecture 20 (last content lecture) Wrapping up (slicing problem, smart pointers) Tuesday 1 st April, 9am demo lecture is replaced by lab time to work on coursework : I will go to the A32 lab to answer questions Friday (4 th April): Revision Lecture and exam strategy On the following week I will go to the A32 lab for the Monday (7 th 5pm) and Tuesday (8 th 9am) lecture slots Coursework deadline: 4pm Tuesday 8 th April 38