Advanced C ++ Philip Blakely. Laboratory for Scientific Computing, University of Cambridge. Philip Blakely (LSC) Advanced C++ 1 / 119

Size: px

Start display at page:

Download "Advanced C ++ Philip Blakely. Laboratory for Scientific Computing, University of Cambridge. Philip Blakely (LSC) Advanced C++ 1 / 119"

Victor Carter
5 years ago
Views:

1 Advanced C ++ Philip Blakely Laboratory for Scientific Computing, University of Cambridge Philip Blakely (LSC) Advanced C++ 1 / 119

2 Part I C Philip Blakely (LSC) Advanced C++ 2 / 119

3 C C was standardized in You may see references to C ++ 0x in old documentation. It incorporates useful constructs from the Boost libraries. New container types. Lambda functions Features geared towards ease of optimization. These lectures assume that you are a reasonably competent C ++ user. Check what version of C ++ your compiler defaults to. For gcc use the --std=c++11 flag. Philip Blakely (LSC) Advanced C++ 3 / 119

4 References Bjarne s guide to differences between C and C ++ 11: Bjarne Stroustrup, The C ++ Programming Language, 4th Edition, Addison Wesley - has clear indication of which features are in C and C (and C and C ++ 17). Virtually every topic in this course has an associated example code in the Examples directory. In some cases I have used the macro AVOID INTENTIONAL ERRORS to allow me to check for correct compilation. Philip Blakely (LSC) Advanced C++ 4 / 119

5 Detecting C If you write code that requires C syntax, and someone accidentally compiles with a C compiler, then they will have a large number of errors. A simple way to detect whether you have a C compiler is: #if cplusplus < L #error This program requires a C++11 compiler. #endif The equivalent numbers for all versions are: L (C ++ 98) L (C ++ 11) L (C ++ 14) L (C ++ 17) Philip Blakely (LSC) Advanced C++ 5 / 119

6 NULL pointer In C you would use NULL or 0 to represent an undefined pointer. In C you should use nullptr instead. This provides for better readability and for distinctness in overloading to accept either an integer or a pointer. See Examples/null.C Philip Blakely (LSC) Advanced C++ 6 / 119

7 enum classes In C we had enums: enum Colour{Red, Green, Blue; which defines a type Colour at global scope that implicitly converts to an int: Colour b = Blue; int r = Red; In C we have a strongly typed enum class: enum class ProperColour : char { Cyan, Magenta, Yellow, Black ; which defines a type ProperColour with its own scope that uses a char to store its value, but does not implicitly convert to an char: ProperColour c = ProperColour::Cyan; char y = (char)propercolour::yellow; See Examples/enum.C Philip Blakely (LSC) Advanced C++ 7 / 119

8 Template closing brackets A problem you didn t know you had: std::vector<std::pair<int,int>> a; is invalid in C In C >> is interpreted as a right-shift operator, following the maximal munch principle. In C you need a space between the two > brackets. From C the above syntax is valid. In some (fairly contrived) cases, this may cause code to give different results under C and C See /n1757.html See Examples/maxMunch.C. Philip Blakely (LSC) Advanced C++ 8 / 119

9 Constant values Template parameters (for example) must have their values known at compile-time. In C we are restricted to using static const int members and using recursive templates if we want to do any complex calculations. In C we can declare a function to be a constexpr, specifying that it can be evaluated at compile-time: constexpr int triang(int n){ return (n>1)? n + triang(n 1) : 1; We can then use it as a template parameter (Examples/constexpr.C): template<int D> struct Vector{ double m data[d]; ; Vector<triang(5)> a; Philip Blakely (LSC) Advanced C++ 9 / 119

10 Constant values There are restrictions to using constexpr: It must consist of a single return statement. It must not contain any local variables. It must not have side-effects, e.g. modifying a global variable. A constexpr function can be used to initialize any static const member. Philip Blakely (LSC) Advanced C++ 10 / 119

11 Constant values - non-integral Note that non-integral static const members are now permitted in C ++ 11, and can be initialized inside the class: constexpr double expon(double n){ return exp(n); template<int D> struct Vector{ static constexpr double m val = expon(d); ; See Examples/constexprfloat.C Philip Blakely (LSC) Advanced C++ 11 / 119

12 Automatic type declarations Consider the following C code: int countpassengers(const std::list<const Vehicle >& vehicles){ int numpass = 0; for(std::list<const Vehicle >::const iterator it = vehicles.begin() ; it!= vehicles.end() ; ++it ){ numpass += it >numpass(); return numpass; The type of it is complicated to type, and adds length to the code line without adding useful information. In C we can type: for(auto it = vehicles.begin() ; it!= vehicles.end() ; ++it ){ The auto keyword declares the variable it to be the exact type on the right of the equality. Philip Blakely (LSC) Advanced C++ 12 / 119

13 Initializer lists In C initializing a std::vector of values was annoying: std::vector<int> a(4); a[0] = 1; a[1] = 2; a[2] = 3; a[3] = 5; (Even initializing from int a2[4] = {1,2,3,5 is awkward.) There is an easier way in C ++ 11: std::vector<int> a{1, 2, 3, 5; This works for std::list as well. Similarly, for a std::map: std::map<int, double> b{ {1, M PI, {2, M E, {6, See Examples/init-list.C Philip Blakely (LSC) Advanced C++ 13 / 119

14 Initializer list constructors How can you use this syntax in your own constructors? We would like to have: Matrix rotate{{cos(theta), sin(theta), {+sin(theta), cos(theta); C provides a special type which is passed to constructors: std::initializer list, requiring the header #include <initializer list> This acts as a generic container, which can be iterated over, with the bare minimum of begin(), end(), size() Philip Blakely (LSC) Advanced C++ 14 / 119

15 Initializer list constructors For a 2 2 matrix class: Matrix::Matrix(std::initializer list< std::pair<double, double>> args){ size t i=0; for(auto it = args.begin() ; it!= args.end() ; ++it, ++i){ data[i][0] = ( it).first; data[i][1] = ( it).second; For each pair of doubles in the provided list, we set the elements of data[2][2]. Matrix m{{0, 1, {3, 4; This could be extended to generic-sized matrices via an initializer list<std::vector<double> > See Examples/init-list.C Philip Blakely (LSC) Advanced C++ 15 / 119

16 Automatic type declarations ctd The std::max function takes the form: template<typename T> max(const T& t1, const T& t2){... which causes an error if you try to call std::max(1, 2.0). The solution is to use std::max<double>(1, 2.0). Consider the following alternative: template<typename T1, typename T2> TYPE max(const T1& t1, const T2& t2){ return (t1 > t2)? t1 : t2; What goes in place of the TYPE? It can t be T1 or T2 themselves. We can use typename std::common type<t1, T2>::type This is defined to be the resulting type of (true)? t1 : t2. (Strictly it s (true)? declval<t1>() : declval<t2>()) See Examples/max.C Philip Blakely (LSC) Advanced C++ 16 / 119

17 Automatic type declarations ctd A similar problem to the above is: template<typename T, typename S>?? operator (const std::vector<t>& v, const S& s) i.e. multiplication of a vector class with elements of type T by a scalar of type S. What if T = int and S = double? You could start using std::common type but this may not work if you start creating your own types. The solution is decltype: template<typename T, typename S> auto operator (const std::vector<t>& v, const S& s) > std::vector<decltype(t{ S{)> {... This syntax declares the result s contained type to be the type that would result from the product of scalars of types T and S. See Examples/vector.C Philip Blakely (LSC) Advanced C++ 17 / 119

18 Range-based for loops In C we often had the following long syntax: for(std::list<int>::const iterator iter = l.begin() ; iter!= l.end() ; ++iter) In C we can use: for( const int& i : l ){ std::cout << i << ", "; for( int& i : l ){ i = 2; We can even iterate over an in-place array: for(double p : {1., 4., 9., 10., M PI ){ std::cout << "sqrt(" << p << ") = " << sqrt(p); See Examples/for-loops.C. Philip Blakely (LSC) Advanced C++ 18 / 119

19 noexcept In C it was possible to indicate that certain functions would never throw an exception, using throw(). In C this is replaced by noexcept: Vector::Vector()noexcept{ m data = nullptr; m size = 0; noexcept is part of the function signature in the same way as const, for example. If a noexcept function does throw an exception, the program will immediately terminate. This differs from default behaviour which would require that the exception propagate up the function stack until a matching catch() was found. Philip Blakely (LSC) Advanced C++ 19 / 119

20 Return Value Optimization Consider the overloaded operator: Vector operator+(const Vector& a, const Vector& b){ Vector c(a.size()); for(size t i=0 ; i < a.size() ; i++){ c[i] = a[i] + b[i]; return c; Vector d = a + b; In C ++ 03, with typical copy/assign-constructors, this can result in c being created, then copied into a newly created d. This seems wasteful, as c will immediately be destroyed. The Return Value Optimization allows compilers to avoid making this copy, and only creating the final destination d. In fact, gcc will do this at -O0 unless you explicitly disable it via -fno-elide-constructors. See Examples/move.C, compiling in C mode with and without -fno-elide-constructors. Philip Blakely (LSC) Advanced C++ 20 / 119

21 Thwarting the Return Value Optimization However the RVO is easily thwarted by adding the following (not entirely unreasonable) code into operator+: if(a.size()!= b.size()){ return Vector(0); There is no longer a single return point from the function, and the result Vector is not necessarily always the same one. Now, if we compile move.c with -DFORCE COPY in C mode, it includes the above code and we always have a copy-constructor call. Thus, adding the above will result in (possibly) slower code than before, for no particularly good reason. Philip Blakely (LSC) Advanced C++ 21 / 119

22 Move syntax C provides a way to move an object instead of copying it. This is used when we know the object being copied from will no longer be used (e.g. the returned c in the previous example). Vector(Vector&& a){ m size = a.m size; m data = a.m data; a.m data = NULL; a.m size = 0; Instead of copying the data element by element, we copy the data pointer itself. We cannot write the normal copy-constructor this way because then two Vectors would point to the same data. Note that since a is about to be destroyed, its contents must be something that the destructor will handle safely. Compiling Examples/move.C with C support results in no slow copy functions being called. Philip Blakely (LSC) Advanced C++ 22 / 119

23 Move into containers There are now functions to add elements to containers using move-syntax: std::vector<vector> vecs; Vector a(10); vecs.push back(std::move(a)); The std::move syntax comes from the <utility> header, and indicates that the variable should be moved rather than copied. Since we defined the Vector::Vector(Vector&& v) function to invalidate the contents of v, the size of a above will be zero after the std::move() call. You should not attempt to use a after the above has been called. See Examples/moveContainer.C. Philip Blakely (LSC) Advanced C++ 23 / 119

24 Move into containers Following the principles of Resource Allocation Is Initialization (RAII), std containers will attempt to move their elements, but only if the move operation is guaranteed not to throw an exception. If a std::vector needs to copy all of its data into a new region of memory (due to a push back for example), it will use the normal copy constructor unless it is guaranteed that the move-constructor will not throw an exception. So, we should declare the move-constuctor noexcept: Vector(Vector&& a)noexcept {... Then, multiple insertions into an std::vector will not result in any slow copies. Philip Blakely (LSC) Advanced C++ 24 / 119

25 Move into containers Examples/moveContainer.C demonstrates a copy-insertion, an in-place construct and push-back, and an explicit moving push-back: vecs.push back(a); vecs.push back(vector(10)); vecs.push back(std::move(a)); With fully implemented move functions, only the first one performs a slow copy. If we omit the noexcept, then slow copies result when the vector has to reallocate its memory. Philip Blakely (LSC) Advanced C++ 25 / 119

26 Emplace If move semantics had not been implemented for Vector, then: vecs.push back(vector(10)); causes a construction and then copy-construct. Even with move semantics, it still causes a construct and move. However, an emplace will construct in-place: vecs.emplace back(10); The 10 corresponds to the parameters to be passed to the constructor. Other emplace functions are available for various containers, e.g: std::list<int> numbers; numbers.emplace(iter, 20) where the iterator indicates the position before which to insert the new element. std::map<std::string, int> ages; ages.emplace("tom", 10); Philip Blakely (LSC) Advanced C++ 26 / 119

27 Move/Emplace performance As usual, you should consider readability before performance. The only reason that move-semantics give better performance is that there are non-trivial resources associated with a Vector. The emplace approach only avoids an extra move call. However, if we did not have move-semantics, and used emplace, it would save a copy-construct. Philip Blakely (LSC) Advanced C++ 27 / 119

28 New containers: forward list As an alternative to std::list, which is bidirectional, forward list is singly-linked. It is more space-efficient than std::list. Philip Blakely (LSC) Advanced C++ 28 / 119

29 New containers: unordered map Recall that a std::map<key, Value> relies on an ordering on the Key type. This allows a new element to be inserted with complexity O(log(N)) where N is the number of elements in the map. It is likely that the map is implemented as a binary-tree so that searching for the correct insertion point requires searching down tree branches. (There is the option to insert using an iterator as a hint where to put the new element.) What if you have a Key with no ordering? C now has a hashed map, called std::unordered map. Philip Blakely (LSC) Advanced C++ 29 / 119

30 New containers: unordered map std::unordered map<key, Value> relies on the existence of a hash function from Key to size t. The cost of insertion is now O(1). The third template parameter is a functional which defaults to std::hash<key> and is defined for all basic types, strings and a few other types (not containers). The hash functional maps a Key type to a size t and should map different Keys to different values as far as possible. If a hash-collision occurs, then a bucket is created to hold all Keys that hash to this value. A poor hash function can therefore reduce the efficiency of a std::unordered map to have O(N) complexity for insertion if many hash-collisions occur. Philip Blakely (LSC) Advanced C++ 30 / 119

31 Creating a new hash functional Suppose we have a 2D coordinate type: struct Coord{ Coord(int i, int j) : x(i), y(j){ bool operator==(const Coord& b)const{ return (x == b.x) && (y == b.y); int x; int y; ; Create a functional: struct hashcoord{ size t operator()(const Coord& a)const{ return std::hash<int>()(a.x) ˆ std::hash<int>()(a.y); ; Note that std::hash<int> is a type, so std::hash<int>() is an object of that type, which has an operator operator()(int) Philip Blakely (LSC) Advanced C++ 31 / 119

32 Creating a new hash functional The ^ exclusive OR operator ensures that the results of the underlying hash functions are combined so as to give a result which is also size t. Now we can use the Coord as a key as follows: std::unordered map<coord, double, hashcoord> cellvalues; Coord a(1,3); cellvalues[a] = 3.0; See Examples/unordered map.c Philip Blakely (LSC) Advanced C++ 32 / 119

33 New containers: unordered map There are other related new containers: std::unordered set std::unordered multiset std::unordered multimap Philip Blakely (LSC) Advanced C++ 33 / 119

34 New containers: array C now has a fixed-size array type, essentially containing a C-like array: #include <array> std::array<double, 5> a{1,4,9,16,25; a[2] = 36; std::sort(a.begin(), a.end()); for(size t i=0 ; i < a.size() ; i++){ std::cout << "a[" << i << "] = " << a[i] << std::endl; Importantly, this does not decay to a double* when being passed to a function. See Examples/array.C Philip Blakely (LSC) Advanced C++ 34 / 119

Part X. Advanced C ++

Part X. Advanced C ++ Part X Advanced C ++ topics Philip Blakely (LSC) Advanced C++ 158 / 217 References The following are highly regarded books. They are fairly in-depth, and I haven t read them in their entirity. However,