C++11 Move Constructors and Move Assignment. For Introduction to C++ Programming By Y. Daniel Liang

Transcription

1 C++11 Move Constructors and Move Assignment For Introduction to C++ Programming By Y. Daniel Liang C+11 provides move constructors and move assignment to improve performance by moving a large rvalue object rather than copying it. Recall that an rvalue is a temporary value that disappears after it is used. To see the need for using move semantics, let us look at the following example in Listing 1. Listing 1 NeedMoveDemo.cpp 1 #include <iostream> 2 #include <vector> 3 using namespace std; 4 5 vector<int> getvector(int x1, int x2, int x3) 6 { 7 return vector<int>{x1 + x2, x2 + x3, x3 + x1}; 8 } 9 10 int main() 11 { 12 vector<int> v = getvector(1, 2, 3); 13 for (int e : v) cout << e << " "; return 0; 16 } <Sample output> <End sample output> Invoking getvector(x1, x2, x3) returns a vector (line 12). Before C++11, assigning the vector to v performs a copy by invoking the vector s copy constructor. After the copy, the vector returned from the function is destroyed. This is inefficient. C++11 enables you to use a move constructor to move the vector to v, rather than copying the vector to v. Moving is possible because the vector returned from the function is an rvalue. Without using a move, the rvalue is destroyed after its use. Using move, the rvalue is retained and simply moved to v. The vector is a standard C++ class. Its move constructor is 8

2 implemented in C++11. To see a move constructor at work behind the scene, we will revise the Course class in Listing CourseWithAssignmentOperatorOverloaded.h and in Listing CourseWithAssignmentOperatorOverloaded.cpp to add a move constructor and a move assignment operator. Every class has a constructor. If no constructor is defined explicitly, a default non-arg constructor is automatically provided. Every class has a copy constructor, an assignment operator, a destructor, a move constructor, and a move assignment operator. If your class does not use any dynamic data fields, you don t have to do anything. C++ automatically provides a default implementation for these five members. These five members are called Big Five, means if you implement one, you should implement all five. This is called the rule of the Big Five. Recall that the signatures for the copy constructor, assignment operator, and destructor are as follows: ClassName(const ClassName&) // Copy constructor ClassName& operator=(const ClassName&) // Assignment operator ~ClassName() // Destructor The signatures for the move constructor and move assignment operators are ClassName(ClassName&&) // Copy constructor ClassName& operator=(classname&&) // Assignment operator Here ClassName& is known as pass-by-reference. In C++11, precisely, it is called pass-by-lvalue-reference. ClassName&& is called as pass-by-rvalue-reference. You can only pass an lvalue to ClassName& and an rvalue to ClassName&&. The vector class has all Big Five members. Consider the following code: vector<int> v2{1, 2, 3}; vector<int> v1 = v2; Recall that an object is an rvalue if it does not persist after the expression is evaluated. Here v2 is an lvalue. Since v2 is an lvalue, the vector s copy constructor is used for vector<int> v1 = v2. When you write the following code: vector<int> v1 = getvector(1, 2, 3); Since getvector(1, 2, 3) returns an rvalue, the vector s move constructor is used for vector<int> v1 = getvector(1, 2, 3). The Course class in Listing already has a copy 9

3 constructor, an assignment operator, and a destructor. We now add a move constructor and a move assignment operator into the Course class as shown in Listing 2 and implement it in Listing 3. Listing 2 CourseWithMove.h 1 #ifndef COURSE_H 2 #define COURSE_H 3 #include <string> 4 using namespace std; 5 6 class Course 7 { 8 public: 9 Course(const string& coursename, int capacity); 10 ~Course(); // Destructor 11 Course(Course&); // Copy constructor 12 Course& operator=(const Course& course); 13 Course(Course&& course); 14 Course& operator=(course&& course); 15 string getcoursename() const; 16 void addstudent(const string& name); 17 void dropstudent(const string& name); 18 string* getstudents() const; 19 int getnumberofstudents() const; private: 22 string coursename; 23 string* students; 24 int numberofstudents; 25 int capacity; 26 }; #endif Listing 3 CourseWithMove.cpp 1 #include <iostream> 2 #include "CourseWithMove.h" 3 using namespace std; 4 5 Course::Course(const string& coursename, int capacity) 6 { 7 numberofstudents = 0; 8 this->coursename = coursename; 9 this->capacity = capacity; 10 students = new string[capacity]; 11 } Course::~Course() 14 { 15 delete [] students; 16 } 10

4 17 18 string Course::getCourseName() const 19 { 20 return coursename; 21 } void Course::addStudent(const string& name) 24 { 25 if (numberofstudents >= capacity) 26 { 27 cout << "The maximum size of array exceeded" << endl; 28 cout << "Program terminates now" << endl; 29 exit(0); 30 } students[numberofstudents] = name; 33 numberofstudents++; 34 } void Course::dropStudent(const string& name) 37 { 38 // Left as an exercise 39 } string* Course::getStudents() const 42 { 43 return students; 44 } int Course::getNumberOfStudents() const 47 { 48 return numberofstudents; 49 } Course::Course(Course& course) // Copy constructor 52 { 53 coursename = course.coursename; 54 numberofstudents = course.numberofstudents; 55 capacity = course.capacity; 56 students = new string[capacity]; 57 for (int i = 0; i < numberofstudents; i++) 58 students[i] = course.students[i]; 59 cout << "Copy constructor called" << endl; 60 } Course& Course::operator=(const Course& course) 63 { 64 if (this!= &course) // Do nothing with self-assignment 65 { 66 coursename = course.coursename; 67 numberofstudents = course.numberofstudents; 68 capacity = course.capacity; delete [] this->students; // Delete the old array // Create a new array with the same capacity as course copied 73 students = new string[capacity]; 74 for (int i = 0; i < numberofstudents; i++) 75 students[i] = course.students[i]; 76 } 11

5 77 cout << "Assignment operator called" << endl; return *this; 80 } Course::Course(Course&& course) 83 { 84 coursename = course.coursename; 85 numberofstudents = course.numberofstudents; 86 capacity = course.capacity; 87 // No need to create new students array 88 students = course.students; // Move course.students 89 course.students = nullptr; // course.students is set to nullptr 90 cout << "Move constructor called" << endl; 91 } // Implement move assignment 94 Course& Course::operator=(Course&& course) 95 { 96 if (this!= &course) // Do nothing with self-assignment 97 { 98 coursename = course.coursename; 99 numberofstudents = course.numberofstudents; 100 capacity = course.capacity; 101 // No need to create new students array 102 students = course.students; // Move course.students 103 course.students = nullptr; // course.students is set to nullptr 104 } 105 cout << "Move assignment operator called" << endl; return *this; 108 } In the move constructor and the move assignment, the move is implemented by letting students point to course.students and set course.students to nullptr (lines and lines ). We now give a test program to use the move constructor and move assignment in Listing 4. Listing 4 CourseWithMoveDemo.cpp 1 #include <iostream> 2 #include "CourseWithMove.h" 3 using namespace std; 4 5 Course getcourse(course c) 6 { 7 return c; 8 } 9 10 int main() 11 { 12 Course course1("java Proramming", 10); 13 Course course2 = course1; // Use copy constructor 14 course2 = course1; // Use assignment operator 12

6 15 16 Course course3 = getcourse(course1); // Use move constructor 17 course2 = Course("Python", 33); // Use move assignement return 0; 20 } <Sample output> Copy constructor called Assignment operator called Copy constructor called Move constructor called Move assignment operator called <End sample output> In line 12, course1 is created using the Course constructor. In line 13, the Course s copy constructor is used to create a course. In line 14, the Course s assignment operator is used to copy course1 to course2. In line 16, Course s move constructor is used to move the Course object returned from getcourse(course) to course3. Note that invoking getcourse(course) makes a copy of course to c using the Course class s copy constructor and getcourse(course) returns a Course object, which is an rvalue. In line 17, the Course s move assignment is used to move the object to course2. Note that Course("Python", 33) creates an unnamed Course object, which is an rvalue. 13