lecture05: The Big Three

Size: px

Start display at page:

Download "lecture05: The Big Three"

Hope Phillips
6 years ago
Views:

1 lecture05: Largely based on slides by Cinda Heeren CS 225 UIUC 17th June, 2013

2 Announcements mp1 due tonight at 11pm mp2 released tonight Significantly longer than mp1! Make sure to start early and use the provided test cases lab memory tomorrow morning

3 This class s class book.h */ // from now on, let s omit // inclusion guards for brevity #include <string> using std::string; class Book public: Book(const string & title); ~Book(); private: string _title; string* _lines; ; book.cpp */ #include "book.h" Book::Book(const string & title): _title(title) _lines = new string[100]; Book::~Book() delete [] _lines; // note: it s common practice // to prefix private member // variables with an underscore

4 Using a Book // We can use the book class as we expect Book mybook("speaker for the Dead"); Book* other = new Book("Children of the Mind"); delete other; // What if we want to make a copy of a book? Book mycopy(mybook); // the object mycopy is a copy of "Speaker for the Dead"

5 You wouldn t copy a book There s a problem with calling the implicit copy constructor of our Book class. The system-provided copy constructor essentially performs the following steps: Book mycopy; mycopy._title = mybook._title; mycopy._lines = mybook._lines; // ok? // ok? By default, a shallow copy is made! Can you draw a picture of what happens?

6 Making a shallow copy of a Book

7 I would copy a book In order to fix this problem, we need to define our own copy constructor This is similar to creating our own constructor to override the default system one Our copy constructor will copy over all member variables from a parameter object to the current object, ensuring deep copies are made Let s check out our modified Book class...

8 Adding the copy constructor book.h */ #include <string> using std::string; class Book public: Book(const string & title); Book(const Book & other); ~Book(); private: string _title; string* _lines; ; book.cpp */ #include "book.h" Book::Book(const string & title): _title(title) _lines = new string[100]; Book::Book(const Book & other) _title = other._title; _lines = new string[100]; for(size_t i = 0; i < 100; ++i) _lines[i] = other._lines[i]; Book::~Book() delete [] _lines;

9 Points to ponder Now that we defined our own copy constructor, each book created with it has its own memory Why pass in other by reference? Why is other a const variable? Remember, by default all objects have a default shallow-copy copy constructor!

10 What else can we do? // So now we can safely do this: Book another("shadow of the Hegemon"); Book same(another); // But what about this? Book another("shadow of the Hegemon"); Book same = another; // Are the same issues encountered with = // as with the copy constructor?

11 Operator overloading Yes! By default, operator= in C++ makes a shallow copy Fortunately, in C++ we can overload operators to make operator= do exactly what we want In a very similar way to the copy constructor, we can add an operator= method to our Book class It s a class member because it can also be written as same.operator=(another); Think about it as lhs.operator=(rhs);

12 Adding operator= book.h */ #include <string> using std::string; class Book public: Book(const string & title); Book(const Book & other); Book & operator=(const Book & rhs); ~Book(); book.cpp */ Book & Book::operator=(const Book & rhs) // protect against re-assignment // clear lhs // copy rhs private: string _title; string* _lines; // return a helpful value ;

13 Adding operator= book.h */ #include <string> using std::string; class Book public: Book(const string & title); Book(const Book & other); Book & operator=(const Book & rhs); ~Book(); private: string _title; string* _lines; ; book.cpp */ Book & Book::operator=(const Book & rhs) // protect against re-assignment if(this!= &rhs) // clear lhs delete [] _lines; // copy rhs _title = rhs._title; _lines = new string[100]; for(size_t i = 0; i < 100; ++i) _lines[i] = rhs._lines[i]; // return a helpful value return *this;

14 Don t duplicate your code!! book.h */ class Book public: Book(const string & title); Book(const Book & other); Book & operator=(const Book & rhs); ~Book(); private: string _title; string* _lines; void copy(const Book & other); void clear(); ; book.cpp */ Book::Book(const Book & other) copy(other); Book & Book::operator=(const Book & rhs) if(this!= &rhs) clear(); copy(rhs); return *this; Book::~Book() clear();

15 Things to think about Why not if(*this!= rhs)? Why return a Book &?

16 So why was this lecture called? Any guesses what the big three are in C++? Why? If you have any reason to implement one of the big three, you must implement all of them! The above item was bold, it must be important Disclaimer: the rule of three becomes the rule of five in C++11 (which we don t use in this class). Just be aware!

lecture30: Beyond CS 225

lecture30: Beyond CS 225 Sean Massung CS 225 UIUC 31st July, 2013 Announcements lab graphs due tomorrow, 8/1 at 11pm final exam this Friday (8/2), 10:30am-12:30pm in this room Anything but Hello World