CS11 Advanced C++ Spring 2018 Lecture 2

Transcription

1 CS11 Advanced C++ Spring 2018 Lecture 2

2 Lab 2: Completing the Vector Last week, got the basic functionality of our Vector<T> template working It is still missing some critical functionality Iterators are required for using collections with C++ STL algorithms e.g. sort(), shuffle(), reverse(), Can t use our Vector<T> type with these, yet Our Vector<T> doesn t provide necessary nested member-types e.g. std::vector<t>::value_type or std::vector<t>::const_iterator Our Vector<T> type also doesn t support move semantics Should greatly improve the performance of certain use-cases This week, we will address all of these limitations

3 Standard Template Library (A Review) A very well known part of the C++ Standard Library Primary architect: Alexander Stepanov AT&T Bell Labs, then later Hewlett Packard Andrew Koenig motivated proposal to ANSI/ISO Committee in 1994 Proposal accepted/standardized in 1994 Continuous refinements, increased support Working with the STL requires familiarity with: Class templates and function templates Function pointers Basic data structures / computational complexity 3

4 What Is the Standard Template Library? A set of generic containers, algorithms, and iterators that provide many basic algorithms and data structures of computer science Generic Heavily parameterized; lots of templates! Containers Collections of other objects, with various characteristics Algorithms For manipulating the data stored in containers Iterators A generalization of pointers Cleanly decouple algorithms from containers 4

5 Simple STL Example You want an array of numbers. vector<int> v(3); // Vector of 3 elements v[0] = 7; v[1] = v[0] + 3; v[2] = v[0] + v[1]; Now you want to reverse their order reverse(v.begin(), v.end()); vector<int> is the generic container reverse() is a generic algorithm reverse() uses iterators associated with v 5

6 STL Algorithms Generic function-templates Parameterized on iterator type not container Example: the find() algorithm template <typename InputIterator, typename T> InputIterator find(inputiterator a, InputIterator b, const T& value) { while (a!= b && *a!= value) ++a; return a; } Searches for value in range [a, b) 6

7 Algorithms and Iterators The find() implementation: template <typename InputIterator, typename T> InputIterator find(inputiterator a, InputIterator b, const T& value) { InputIterator isn t a specific type! while (a!= b && *a!= value) ++a; Just needs to support * (dereference), ++ (increment), and equality operators. Pointers also satisfy these requirements float a[5] = { 1.1, 2.3, -4.7, 3.6, 5.2 }; float *pval; // float* as iterators pval = find(a, a + 5, 3.6); 7

8 Concepts This set of functionality required for the iterator-type is called a concept In this case, the concept is named InputIterator A type that satisfies the requirements is said to model the concept Or, it conforms to the concept Given our previous example: float a[5] = { 1.1, 2.3, -4.7, 3.6, 5.2 }; float *pval; // float* as iterators pval = find(a, a + 5, 3.6); int* is a model of InputIterator because int* provides all of the operations that are specified by the InputIterator requirements. 8

9 What About reverse()? The reverse() algorithm needs more! Specifically, its iterators also need -- operator. reverse() s arguments must model the BidirectionalIterator concept. Like InputIterator, but with more requirements. BidirectionalIterator refines the InputIterator concept This is exactly like class-inheritance. Different terms because these aren t classes. 9

10 Concepts?! A major issue with the whole concept thing: Up until C++17, there has been no language support whatsoever for declaring or enforcing the requirements of concepts If you used a type with a template, and the type didn t model the required concept: You get a whole bunch of confusing error messages, none of which say This type is inappropriate to use with this thing! C++17 includes an experimental specification for how to declare and enforce concepts C++20 will [hopefully] include functionality to do this 10

11 Iterator Concept Hierarchy Iterator only supports dereference InputIterator also supports increment Only read support is guaranteed. Only single-pass support guaranteed. ForwardIterator like InputIterator Supports multi-pass algorithms. BidirectionalIterator also supports decrement RandomAccessIterator Supports arbitrary-size steps forward and backward ContiguousIterator Logically-contiguous elements are also physically contiguous 11

12 Output Iterators OutputIterators don t appear in the iterator concept hierarchy Different, very limited set of requirements Support assignment Support increment Support postincrement-and-assign *iter++ = value; For modeling output to the console, sockets, etc. You can write to the current location You can advance to the next location 12

13 Vectors and Iterators Generally, iterators are straightforward to implement begin() member-function returns an iterator that points to the first element end() member-function returns an iterator that points just past the last element Example: v[0] v[1] v[2] v[size-1] (empty) begin() end() Can use to loop over vector contents, etc. for (auto it = v.begin(); it!= v.end(); it++) if (*it == value) return it; Iterator type can be anything that implements all requirements, i.e. * (dereference), ++ (increment), and equality operators

14 Vectors and Iterators (2) std::vector specifies some details about its iterators The elements are stored contiguously, which means that elements can be accessed not only through iterators, but also using offsets to regular pointers to elements. This means that a pointer to an element of a vector may be passed to any function that expects a pointer to an element of an array. (since C++03) Can write: Can also write: reverse(v.begin(), v.end()); reverse(&v[0], &v[0] + v.size()); Implication: can use simple pointers as iterators Important note: std::vector s iterators are not simple pointers STL collections also provide rbegin() and rend() reverse iterators Don t mix simple pointers and iterators when working with vectors!

15 Vectors and Iterators (3) Example code: vector<int> v;... // Stuff happens to v auto b = v.begin(); auto e = v.end(); v.push_back(100); Are b and e still valid iterators? b will remain valid, as long as the vector s capacity didn t change e is definitely no longer valid (at least as far as being an end iterator) Certain operations can cause an iterator to become invalid i.e. the operation invalidates the iterator Generally, if a collection changes shape (i.e. reallocations take place) then iterators may become invalidated

16 Iterator Invalidation In general, each container must specify when its iterators may be invalidated Example: A vector s past-the-end iterator is invalidated when an element is inserted or erased A vector s iterators are invalidated when the vector s capacity changes Unfortunately, most collections won t report an error when this occurs Fun experiment: std::vector<int> v; v.reserve(10); auto b = v.begin(); for (int i = 0; i < 1000; i++) { v.push_back(100); cout << *b << "\n"; }

17 Nested Typedefs So far, have been writing, e.g. for (auto it = v.begin(); it!= v.end(); it++) if (*it == value) return it; What is the type of v.begin() or v.end()? C++11 has type-inference, so not as important to know the actual type Many situations where code outside a collection needs to refer to a collection s value-type, iterator-type, etc. Easy way to solve this: STL collections provide nested typedefs that specify common names for their own internal types for (vector<int>::iterator it = v.begin(); it!= v.end(); it++) { if (*it == value) return it; }

18 Nested Typedefs (2) Example implementation: typedef <typename T> class Vector {... public: typedef T value_type; typedef T& reference; typedef const T& const_reference;... // etc. }; Code outside the collection can refer to these typedefs

19 A Data Set Class A simple class to acquire and manage data sets: class DataSet { int capacity; int size; float *samples;... }; samples is an array of float values capacity is the size of the samples array (can be 0) When capacity is 0, samples is set to nullptr size is the number of actual samples in the array at any given time (invariant: size capacity) This is sufficient information to grow samples as needed 19

20 A Data Set Class (2) Our class clearly needs a copy constructor class DataSet { int capacity; int size; float *samples; public:... DataSet(const DataSet &ds); }; Make a deep copy of the data set: capacity = ds.capacity; size = ds.size; samples = new float[capacity]; for (int i = 0; i < size; i++) samples[i] = ds.samples[i]; 20

21 A Data Set Class (3) Methods for our class: class DataSet {... void addsample(float sample); int numsamples() const { return size; } float getsample(int i) const; }; addsample() can store new sample at samples[size] but only if size < capacity! If size == capacity, must increase data set s capacity e.g. capacity = (capacity > 0? capacity * 2 : 16) Allocate a new array of samples; copy contents of old array into new array Delete the old array, and replace it with the new array 21

22 Filtering Data Sets Next, write a function to filter a data set DataSet filterdataset(const DataSet &input, } DataSet output; float maxvalue) { for (int i = 0; i < input.numsamples(); i++) { } float sample = input.getsample(i); if (sample <= maxvalue) return output; output.addsample(sample); Creates a brand new data set, containing results of filtering the input data set 22

23 Filtering Data Sets (2) Example usage: DataSet input; acquiredataset(input); // Any value > 10 is invalid DataSet filtered = filterdataset(input, 10); What does the last line of code actually do? filtered is initialized via copy-constructor 23

24 Filtering Data Sets (3) What does this line of code actually do? DataSet filtered = filterdataset(input, 10); DataSet (temporary) DataSet (local variable) return output; (copy ctor) filterdataset() creates a DataSet local variable that holds the results When the function returns that object, it is copied into a temporary DataSet object representing the entire right-hand side of the assignment Then, function can call destructors on its local objects 24

25 Filtering Data Sets (4) What does this line of code actually do? (cont.) DataSet filtered = filterdataset(input, 10); DataSet (filtered) DataSet (temporary) copy ctor DataSet (local variable) return output; (copy ctor) Next, the temporary object on the RHS is passed to the copy-constructor for filtered Copy-constructor makes a deep copy of samples Finally, the temporary object is also destructed 25

26 Filtering Data Sets (5) What does this line of code actually do? (cont.) DataSet filtered = filterdataset(input, 10); DataSet (filtered) DataSet (temporary) copy ctor DataSet (local variable) return output; (copy ctor) Note: Many compilers optimize this to pass the returned object directly to the final copy constructor Avoids the overhead of constructing and destructing the temporary object Still, we must make a deep copy of an object that we know is about to be destructed 26

27 What If We know that the object inside filterdataset() will be destructed when the function returns DataSet filtered = filterdataset(input); What if we could just move the contents of the returned object directly into filtered? Avoid having to make another deep copy inside the copy constructor Avoid having to clean up heap-allocated data in the object constructed by filterdataset() This optimization became possible in C++11, with the introduction of move semantics 27

28 Lvalues, Rvalues and Rvalue References Our example: DataSet filtered = filterdataset(input); filtered is an lvalue It can be the target of an assignment It persists across multiple statements The object returned by filterdataset() is an rvalue It is a temporary object that will be destructed at the end of statement execution C++11 introduces rvalue references T&& is an rvalue reference to an object of type T Temporary values produced by expressions can be manipulated via rvalue references 28

29 Move Constructors Can define a move constructor for our DataSet class Construction from a temporary object, e.g. DataSet filtered = filterdataset(input); How to implement this constructor? DataSet(DataSet &&ds) { capacity = ds.capacity; size = ds.size; samples = ds.samples; } Are we done? No: also need to set ds.samples = nullptr! Otherwise, temporary object will deallocate our samples when it goes out of scope 29

30 Move Constructors (2) Correct move constructor: DataSet(DataSet &&ds) { capacity = ds.capacity; size = ds.size; samples = ds.samples; ds.samples = nullptr; } 30

31 Move-Assignment Operators Similarly, need to create a move-assignment operator Assignment from a temporary object, e.g. DataSet filtered; filtered = filterdataset(input); Move-assignment operator follows the same idea as the move constructor: DataSet & operator=(dataset &&ds) { capacity = ds.capacity; size = ds.size; samples = ds.samples; ds.samples = nullptr; return *this; } Are we done? No: also need to clean up any samples we had before 31

32 Move-Assignment Operators (2) Now are we done? DataSet & operator=(dataset &&ds) { capacity = ds.capacity; size = ds.size; delete[] samples; samples = ds.samples; ds.samples = nullptr; return *this; } No: we really should also guard against self-assignment 32

33 Move-Assignment Operators (3) Final implementation: DataSet & operator=(dataset &&ds) { if (this!= &ds) { capacity = ds.capacity; size = ds.size; delete[] samples; samples = ds.samples; ds.samples = nullptr; } return *this; } 33

34 Named Data Sets Add a name to our data sets: class DataSet { string name; }; int capacity; int size; float *samples;... 34

35 Named Data Sets (2) Now we have a new problem in move operations: DataSet(DataSet &&ds) { name = ds.name; capacity = ds.capacity; size = ds.size; samples = ds.samples; ds.samples = nullptr; } ds.name is considered an lvalue, so it will be copied instead of being moved Need to tell the compiler it s okay to move the contents of ds.name because it s also temporary 35

36 std::move() Use the std::move() utility function to tell the compiler that something is movable #include <utility> DataSet(DataSet &&ds) { name = std::move(ds.name); capacity = ds.capacity; size = ds.size; samples = ds.samples; ds.samples = nullptr; } std::move() returns an rvalue reference to its argument 36

37 std::move() (2) Generally only need std::move() when your class has datamembers that are objects class DataSet { string name; // Class member! int capacity; int size; float *samples;... }; Generally shouldn t need std::move() very often 37

38 The Rule of Three Five Last time we discussed the Rule of Three: If your class implements a custom copy-constructor, a custom copyassignment operator, and/or a custom destructor, it should probably implement all three. Rule of Three was most relevant until move semantics were introduced into C Now, it s a very good idea to follow the Rule of Five: If your class implements any of the following: A custom copy-constructor A custom copy-assignment operator A custom destructor A custom move-constructor A custom move-assignment operator it should probably implement all five.

39 The Rule of Five The Rule of Five: If your class implements any of the following: A custom copy-constructor A custom copy-assignment operator A custom destructor A custom move-constructor A custom move-assignment operator it should probably implement all five. Are all of these required for correctness? Only the copy-constructor, copy-assignment operator, and destructor are required for correctness Move-constructor and move-assignment operator are focused on achieving high performance Rule of Three is focused on correctness; Rule of Five on correctness and good performance