Scientific programming (in C++)
|
|
|
- Lorena Holt
- 5 years ago
- Views:
Transcription
1 Scientific programming (in C++) F. Giacomini INFN-CNAF School on Open Science Cloud Perugia, June
2 What is C++ C++ is a programming language that is: strongly and statically typed
3 What is C++ C++ is a programming language that is: strongly and statically typed general-purpose
4 What is C++ C++ is a programming language that is: strongly and statically typed general-purpose multi-paradigm
5 What is C++ C++ is a programming language that is: strongly and statically typed general-purpose multi-paradigm efficient ( you don t pay for what you don t use )
6 What is C++ C++ is a programming language that is: strongly and statically typed general-purpose multi-paradigm efficient ( you don t pay for what you don t use ) standard
7 C++ timeline
8 Online resources
9 Standards Working drafts, almost the same as the final published document C C C C For the LaTeX sources see
10 The C++ standard library The standard library contains components of general use containers (data structures) algorithms strings input/output random numbers regular expressions concurrency and parallelism filesystem...
11 The C++ standard library The standard library contains components of general use containers (data structures) algorithms strings input/output random numbers regular expressions concurrency and parallelism filesystem... The subset containing containers and algorithms is known as STL (Standard Template Library)
12 The C++ standard library The standard library contains components of general use containers (data structures) algorithms strings input/output random numbers regular expressions concurrency and parallelism filesystem... The subset containing containers and algorithms is known as STL (Standard Template Library) But templates are everywhere
13 C Arrays Contiguous sequence of homogeneous objects in memory
14 C Arrays Contiguous sequence of homogeneous objects in memory 0x0000 0xab00 0xab04 0xab08 0xab0c 0xffff
15 C Arrays Contiguous sequence of homogeneous objects in memory 0x0000 0xab00 0xab04 0xab08 0xab0c 0xffff int a[3] = {123, 456, 789}; // int[3]
16 C Arrays Contiguous sequence of homogeneous objects in memory 0x0000 0xab00 0xab04 0xab08 0xab0c 0xffff a[0] a[1] a[2] int a[3] = {123, 456, 789}; // int[3]
17 C Arrays Contiguous sequence of homogeneous objects in memory 0x0000 0xab00 0xab04 0xab08 0xab0c 0xffff a[0] a[1] a[2] int a[3] = {123, 456, 789}; // int[3] ++a[0];
18 C Arrays Contiguous sequence of homogeneous objects in memory 0x0000 0xab00 0xab04 0xab08 0xab0c 0xffff a[0] a[1] a[2] int a[3] = {123, 456, 789}; // int[3] ++a[0]; a[3]; // undefined behavior
19 C Arrays Contiguous sequence of homogeneous objects in memory 0x0000 0xaa00 0xab00 0xab04 0xab08 0xab0c 0xffff 0xab b a[0] a[1] a[2] int a[3] = {123, 456, 789}; // int[3] ++a[0]; a[3]; // undefined behavior // "arrays decay to pointers at the slightest provocation" auto b = a; // int*, size information lost
20 C Arrays Contiguous sequence of homogeneous objects in memory 0x0000 0xaa00 0xab00 0xab04 0xab08 0xab0c 0xffff 0xab b a[0] a[1] a[2] int a[3] = {123, 456, 789}; // int[3] ++a[0]; a[3]; // undefined behavior // "arrays decay to pointers at the slightest provocation" auto b = a; // int*, size information lost assert(b == &a[0]);
21 C Arrays Contiguous sequence of homogeneous objects in memory 0x0000 0xaa00 0xab00 0xab04 0xab08 0xab0c 0xffff 0xab b a[0] a[1] a[2] int a[3] = {123, 456, 789}; // int[3] ++a[0]; a[3]; // undefined behavior // "arrays decay to pointers at the slightest provocation" auto b = a; // int*, size information lost assert(b == &a[0]); ++b; // increase by sizeof(int) assert(b == &a[1]);
22 C Arrays Contiguous sequence of homogeneous objects in memory 0x0000 0xaa00 0xab00 0xab04 0xab08 0xab0c 0xffff 0xab b a[0] a[1] a[2] int a[3] = {123, 456, 789}; // int[3] ++a[0]; a[3]; // undefined behavior // "arrays decay to pointers at the slightest provocation" auto b = a; // int*, size information lost assert(b == &a[0]); ++b; // increase by sizeof(int) assert(b == &a[1]); *b = 654;
23 C Arrays Contiguous sequence of homogeneous objects in memory 0x0000 0xaa00 0xab00 0xab04 0xab08 0xab0c 0xffff 0xab0c b a[0] a[1] a[2] int a[3] = {123, 456, 789}; // int[3] ++a[0]; a[3]; // undefined behavior // "arrays decay to pointers at the slightest provocation" auto b = a; // int*, size information lost assert(b == &a[0]); ++b; // increase by sizeof(int) assert(b == &a[1]); *b = 654; b += 2; // increase by 2 * sizeof(int)
24 C Arrays Contiguous sequence of homogeneous objects in memory 0x0000 0xaa00 0xab00 0xab04 0xab08 0xab0c 0xffff 0xab0c b a[0] a[1] a[2] int a[3] = {123, 456, 789}; // int[3] ++a[0]; a[3]; // undefined behavior // "arrays decay to pointers at the slightest provocation" auto b = a; // int*, size information lost assert(b == &a[0]); ++b; // increase by sizeof(int) assert(b == &a[1]); *b = 654; b += 2; // increase by 2 * sizeof(int) *b; // undefined behavior
25 C Arrays Contiguous sequence of homogeneous objects in memory 0x0000 0xaa00 0xab00 0xab04 0xab08 0xab0c 0xffff 0xab0c b a[0] a[1] a[2] int a[3] = {123, 456, 789}; // int[3] ++a[0]; a[3]; // undefined behavior // "arrays decay to pointers at the slightest provocation" auto b = a; // int*, size information lost assert(b == &a[0]); ++b; // increase by sizeof(int) assert(b == &a[1]); *b = 654; b += 2; // increase by 2 * sizeof(int) *b; // undefined behavior if (b == a + 3) {... } // ok, but not more than this
26 Containers Objects that contain and own other objects Different characteristics and operations, some common traits Implemented as class templates Sequence The client decides where an element gets inserted array,vector,list,forward_list, deque Associative The container decides where an element gets inserted Ordered The elements are sorted map,multimap,set, multiset Unordered The elements are hashed unordered_*
27 std::array Type-safe, no-runtime overhead alternative to a native array
28 std::array Type-safe, no-runtime overhead alternative to a native array 0x0000 0xab00 0xab04 0xab08 0xab0c 0xffff a std::array<int,3> a={123, 456, 789}; // size is part of the type
29 std::array Type-safe, no-runtime overhead alternative to a native array 0x0000 0xab00 0xab04 0xab08 0xab0c 0xffff a[0] a[1] a[2] a std::array<int,3> a={123, 456, 789}; // size is part of the type ++a[0];
30 std::array Type-safe, no-runtime overhead alternative to a native array 0x0000 0xab00 0xab04 0xab08 0xab0c 0xffff a[0] a[1] a[2] a std::array<int,3> a={123, 456, 789}; // size is part of the type ++a[0]; a[3]; // undefined behavior
31 std::array Type-safe, no-runtime overhead alternative to a native array 0x0000 0xaa00 0xab00 0xab04 0xab08 0xab0c 0xffff b[0] b[1] b[2] a[0] a[1] a[2] b a std::array<int,3> a={123, 456, 789}; // size is part of the type ++a[0]; a[3]; // undefined behavior auto b = a; // std::array<int, 3>, make a copy! assert(&b[0]!= &a[0]);
32 std::array Type-safe, no-runtime overhead alternative to a native array 0x0000 0xaa00 0xab00 0xab04 0xab08 0xab0c 0xffff 0xab p a[0] a[1] a[2] a std::array<int,3> a={123, 456, 789}; // size is part of the type ++a[0]; a[3]; // undefined behavior auto b = a; // std::array<int, 3>, make a copy! assert(&b[0]!= &a[0]); auto p = &a[0];
33 std::array Type-safe, no-runtime overhead alternative to a native array 0x0000 0xaa00 0xab00 0xab04 0xab08 0xab0c 0xffff 0xab p a[0] a[1] a[2] a std::array<int,3> a={123, 456, 789}; // size is part of the type ++a[0]; a[3]; // undefined behavior auto b = a; // std::array<int, 3>, make a copy! assert(&b[0]!= &a[0]); auto p = &a[0]; ++p; // increase by sizeof(int) assert(p == &a[1]);
34 std::array Type-safe, no-runtime overhead alternative to a native array 0x0000 0xaa00 0xab00 0xab04 0xab08 0xab0c 0xffff 0xab p a[0] a[1] a[2] a std::array<int,3> a={123, 456, 789}; // size is part of the type ++a[0]; a[3]; // undefined behavior auto b = a; // std::array<int, 3>, make a copy! assert(&b[0]!= &a[0]); auto p = &a[0]; ++p; // increase by sizeof(int) assert(p == &a[1]); *p = 654;
35 std::array Type-safe, no-runtime overhead alternative to a native array 0x0000 0xaa00 0xab00 0xab04 0xab08 0xab0c 0xffff 0xab p a[0] a[1] a[2] a std::array<int,3> a={123, 456, 789}; // size is part of the type ++a[0]; a[3]; // undefined behavior auto b = a; // std::array<int, 3>, make a copy! assert(&b[0]!= &a[0]); auto p = &a[0]; ++p; // increase by sizeof(int) assert(p == &a[1]); *p = 654; p += 2; // increase by 2 * sizeof(int)
36 std::array Type-safe, no-runtime overhead alternative to a native array 0x0000 0xaa00 0xab00 0xab04 0xab08 0xab0c 0xffff 0xab0c p a[0] a[1] a[2] a std::array<int,3> a={123, 456, 789}; // size is part of the type ++a[0]; a[3]; // undefined behavior auto b = a; // std::array<int, 3>, make a copy! assert(&b[0]!= &a[0]); auto p = &a[0]; ++p; // increase by sizeof(int) assert(p == &a[1]); *p = 654; p += 2; // increase by 2 * sizeof(int) *p; // undefined behavior
37 std::array Type-safe, no-runtime overhead alternative to a native array 0x0000 0xaa00 0xab00 0xab04 0xab08 0xab0c 0xffff 0xab0c p a[0] a[1] a[2] a std::array<int,3> a={123, 456, 789}; // size is part of the type ++a[0]; a[3]; // undefined behavior auto b = a; // std::array<int, 3>, make a copy! assert(&b[0]!= &a[0]); auto p = &a[0]; ++p; // increase by sizeof(int) assert(p == &a[1]); *p = 654; p += 2; // increase by 2 * sizeof(int) *p; // undefined behavior if (p == a.data() + a.size()) {... } // ok
38 std::array template<class T, unsigned N> class array { T elems[n]; // no space overhead wrt to native array public: size_t size() const { return N; } T* data() { return elems; } T const* data() const { return elems; } T& operator[](unsigned n) { return elems[n]; } // no checks! T const& operator[](unsigned n) const { return elems[n]; }... }; template<class T, unsigned N> bool operator==(array<t, N> const& l, array<t, N> const& r) { return std::equal(l.data(), l.data() + N, r.data()); } template<class T, unsigned N> bool operator<(array<t, N> const& l, array<t, N> const& r) { return std::lexicographical_compare( l.data(), l.data() + N, r.data(), r.data() + N ); }...
39 Algorithms Generic functions that operate on ranges of objects Implemented as function templates
40 Algorithms Generic functions that operate on ranges of objects Implemented as function templates Non-modifying all_of any_of for_each count count_if mismatch equal find find_if adjacent_find search...
41 Algorithms Generic functions that operate on ranges of objects Implemented as function templates Non-modifying all_of any_of for_each count count_if mismatch equal find find_if adjacent_find search... Modifying copy fill generate transform remove replace swap reverse rotate shuffle sample unique...
42 Algorithms Generic functions that operate on ranges of objects Implemented as function templates Non-modifying all_of any_of for_each count count_if mismatch equal find find_if adjacent_find search... Modifying copy fill generate transform remove replace swap reverse rotate shuffle sample unique... Partitioning partition stable_partition...
43 Algorithms Generic functions that operate on ranges of objects Implemented as function templates Non-modifying all_of any_of for_each count count_if mismatch equal find find_if adjacent_find search... Modifying copy fill generate transform remove replace swap reverse rotate shuffle sample unique... Partitioning partition stable_partition... Sorting sort partial_sort nth_element...
44 Algorithms Generic functions that operate on ranges of objects Implemented as function templates Non-modifying all_of any_of for_each count count_if mismatch equal find find_if adjacent_find search... Modifying copy fill generate transform remove replace swap reverse rotate shuffle sample unique... Partitioning partition stable_partition... Sorting sort partial_sort nth_element... Set set_union set_intersection set_difference...
45 Algorithms Generic functions that operate on ranges of objects Implemented as function templates Non-modifying all_of any_of for_each count count_if mismatch equal find find_if adjacent_find search... Modifying copy fill generate transform remove replace swap reverse rotate shuffle sample unique... Partitioning partition stable_partition... Sorting sort partial_sort nth_element... Set set_union set_intersection set_difference... Min/Max min max minmax lexicographical_compare clamp...
46 Algorithms Generic functions that operate on ranges of objects Implemented as function templates Non-modifying all_of any_of for_each count count_if mismatch equal find find_if adjacent_find search... Modifying copy fill generate transform remove replace swap reverse rotate shuffle sample unique... Partitioning partition stable_partition... Sorting sort partial_sort nth_element... Set set_union set_intersection set_difference... Min/Max min max minmax lexicographical_compare clamp... Numeric iota accumulate inner_product partial_sum adjacent_difference...
47 Range A range is defined by a pair of iterators [first, last), with last referring to one past the last element in the range the range is half-open first == last means the range is empty last can be used to return failure An iterator is a generalization of a pointer it supports the same operations, possibly through overloaded operators certainly* ++ -> ==!=, maybe = -= < Ranges are typically obtained from containers calling specific methods
48 Range (cont.) 0x0000 0xab00 0xab04 0xab08 0xab0c a 0xffff std::array<int,3> a = {123, 456, 789};
49 Range (cont.) 0x0000 0xab00 0xab04 0xab08 0xab0c a 0xffff first std::array<int,3> a = {123, 456, 789}; auto first = a.begin(); // or std::begin(a)
50 Range (cont.) 0x0000 0xab00 0xab04 0xab08 0xab0c a 0xffff first last std::array<int,3> a = {123, 456, 789}; auto first = a.begin(); // or std::begin(a) auto last = a.end(); // or std::end(a)
51 Range (cont.) 0x0000 0xab00 0xab04 0xab08 0xab0c a 0xffff first last std::array<int,3> a = {123, 456, 789}; auto first = a.begin(); // or std::begin(a) auto last = a.end(); // or std::end(a) while (first!= last) {... *first...; ++first; }
52 Range (cont.) 0x0000 0xab00 0xab04 0xab08 0xab0c a 0xffff first last std::array<int,3> a = {123, 456, 789}; auto first = a.begin(); // or std::begin(a) auto last = a.end(); // or std::end(a) while (first!= last) {... *first...; ++first; }
53 Range (cont.) 0x0000 0xab00 0xab04 0xab08 0xab0c a 0xffff first last std::array<int,3> a = {123, 456, 789}; auto first = a.begin(); // or std::begin(a) auto last = a.end(); // or std::end(a) while (first!= last) {... *first...; ++first; }
54 Range (cont.) 0x0000 0xab00 0xab04 0xab08 0xab0c a 0xffff first last std::array<int,3> a = {123, 456, 789}; auto first = a.begin(); // or std::begin(a) auto last = a.end(); // or std::end(a) while (first!= last) {... *first...; ++first; }
55 Range (cont.) 0x0000 0xab00 0xab04 0xab08 0xab0c a 0xffff first last std::array<int,3> a = {123, 456, 789}; auto first = a.begin(); // or std::begin(a) auto last = a.end(); // or std::end(a) while (first!= last) {... *first...; ++first; }
56 Range (cont.) 0x0000 0xab00 0xab04 0xab08 0xab0c a 0xffff first last std::array<int,3> a = {123, 456, 789}; auto first = a.begin(); // or std::begin(a) auto last = a.end(); // or std::end(a) while (first!= last) {... *first...; ++first; }
57 Range (cont.) 0x0000 0xab00 0xab04 0xab08 0xab0c a 0xffff first last std::array<int,3> a = {123, 456, 789}; auto first = a.begin(); // or std::begin(a) auto last = a.end(); // or std::end(a) while (first!= last) {... *first...; ++first; }
58 Range (cont.) 0x0000 0xab00 0xab04 0xab08 0xab0c a 0xffff first last std::array<int,3> a = {123, 456, 789}; auto first = a.begin(); // or std::begin(a) auto last = a.end(); // or std::end(a) while (first!= last) {... *first...; ++first; }
59 Range (cont.) 0x0000 0xab00 0xab04 0xab08 0xab0c a 0xffff first last std::array<int,3> a = {123, 456, 789}; auto first = a.begin(); // or std::begin(a) auto last = a.end(); // or std::end(a) while (first!= last) {... *first...; ++first; }
60 Range (cont.) 0x0000 0xab00 0xab04 0xab08 0xab0c a 0xffff first last std::array<int,3> a = {123, 456, 789}; auto first = a.begin(); // or std::begin(a) auto last = a.end(); // or std::end(a) while (first!= last) {... *first...; ++first; } std::array<t>::iterator models the RandomAccessIterator concept
61 Range (cont.) 0x0000 0xab00 0xab04 0xab08 0xab0c a 0xffff first last std::array<int,3> a = {123, 456, 789}; auto first = a.begin(); // or std::begin(a) auto const last = a.end(); // or std::end(a) while (first!= last) {... *first...; ++first; } std::array<t>::iterator models the RandomAccessIterator concept
62 Generic programming A style of programming in which algorithms are written in terms of concepts
63 Generic programming A style of programming in which algorithms are written in terms of concepts A concept is a set of requirements that a type needs to satisfy e.g. supported expressions, nested typedefs, memory layout,...
64 Generic programming A style of programming in which algorithms are written in terms of concepts A concept is a set of requirements that a type needs to satisfy e.g. supported expressions, nested typedefs, memory layout,... template <class Iterator, class T> Iterator find(iterator first, Iterator last, const T& value) { for (; first!= last; ++first) if (*first == value) break; return first; }
65 Range (cont.) 0x0000 0xab00 0xac04 0xad08 0xae0c 0xffff l std::forward_list<int> l = {123, 456, 789}; std::forward_list<t>::iterators models the ForwardIterator concept
66 Range (cont.) 0x0000 0xab00 0xac04 0xad08 0xae0c 0xffff l first std::forward_list<int> l = {123, 456, 789}; auto first = l.begin(); std::forward_list<t>::iterators models the ForwardIterator concept
67 Range (cont.) 0x0000 0xab00 0xac04 0xad08 0xae0c 0xffff l first last std::forward_list<int> l = {123, 456, 789}; auto first = l.begin(); auto const last = l.end(); std::forward_list<t>::iterators models the ForwardIterator concept
68 Range (cont.) 0x0000 0xab00 0xac04 0xad08 0xae0c 0xffff l first last std::forward_list<int> l = {123, 456, 789}; auto first = l.begin(); auto const last = l.end(); while (first!= last) {... *first...; ++first; } std::forward_list<t>::iterators models the ForwardIterator concept
69 Range (cont.) 0x0000 0xab00 0xac04 0xad08 0xae0c 0xffff l first last std::forward_list<int> l = {123, 456, 789}; auto first = l.begin(); auto const last = l.end(); while (first!= last) {... *first...; ++first; } std::forward_list<t>::iterators models the ForwardIterator concept
70 Range (cont.) 0x0000 0xab00 0xac04 0xad08 0xae0c 0xffff l first last std::forward_list<int> l = {123, 456, 789}; auto first = l.begin(); auto const last = l.end(); while (first!= last) {... *first...; ++first; } std::forward_list<t>::iterators models the ForwardIterator concept
71 Range (cont.) 0x0000 0xab00 0xac04 0xad08 0xae0c 0xffff l first last std::forward_list<int> l = {123, 456, 789}; auto first = l.begin(); auto const last = l.end(); while (first!= last) {... *first...; ++first; } std::forward_list<t>::iterators models the ForwardIterator concept
72 Range (cont.) 0x0000 0xab00 0xac04 0xad08 0xae0c 0xffff l first last std::forward_list<int> l = {123, 456, 789}; auto first = l.begin(); auto const last = l.end(); while (first!= last) {... *first...; ++first; } std::forward_list<t>::iterators models the ForwardIterator concept
73 Range (cont.) 0x0000 0xab00 0xac04 0xad08 0xae0c 0xffff l first last std::forward_list<int> l = {123, 456, 789}; auto first = l.begin(); auto const last = l.end(); while (first!= last) {... *first...; ++first; } std::forward_list<t>::iterators models the ForwardIterator concept
74 Range (cont.) 0x0000 0xab00 0xac04 0xad08 0xae0c 0xffff l first last std::forward_list<int> l = {123, 456, 789}; auto first = l.begin(); auto const last = l.end(); while (first!= last) {... *first...; ++first; } std::forward_list<t>::iterators models the ForwardIterator concept
75 Range (cont.) 0x0000 0xab00 0xac04 0xad08 0xae0c 0xffff l first last std::forward_list<int> l = {123, 456, 789}; auto first = l.begin(); auto const last = l.end(); while (first!= last) {... *first...; ++first; } std::forward_list<t>::iterators models the ForwardIterator concept
76 Range (cont.) 0x0000 0xab00 0xac04 0xad08 0xae0c 0xffff l first last std::forward_list<int> l = {123, 456, 789}; auto first = l.begin(); auto const last = l.end(); while (first!= last) {... *first...; ++first; } std::forward_list<t>::iterators models the ForwardIterator concept
77 Range (cont.) 0x0000 0xab00 0xac04 0xad08 0xae0c 0xffff l first last std::forward_list<int> l = {123, 456, 789}; auto first = l.begin(); auto const last = l.end(); while (first!= last) {... *first...; ++first; } std::forward_list<t>::iterators models the ForwardIterator concept
78 Using the standard library #include <array> // note the angular brackets // for standard headers std::array<int,5> a;
79 Using the standard library #include <array> // note the angular brackets #include <random> // for standard headers std::array<int,5> a; std::default_random_engine e; std::uniform_int_distribution<int> dist(1, 6);
80 Using the standard library #include <array> // note the angular brackets #include <random> // for standard headers #include <algorithm> std::array<int,5> a; std::default_random_engine e; std::uniform_int_distribution<int> dist(1, 6); std::generate_n(a.begin(), a.size(), [&](){ return dist(e); });
81 Using the standard library #include <array> // note the angular brackets #include <random> // for standard headers #include <algorithm> std::array<int,5> a; std::default_random_engine e; std::uniform_int_distribution<int> dist(1, 6); std::generate_n(a.begin(), a.size(), [&](){ return dist(e); });
82 Using the standard library #include <array> // note the angular brackets #include <random> // for standard headers #include <algorithm> std::array<int,5> a; std::default_random_engine e; std::uniform_int_distribution<int> dist(1, 6); std::generate_n(a.begin(), a.size(), [&](){ return dist(e); }); std::sort(a.begin(), a.end());
83 Using the standard library #include <array> // note the angular brackets #include <random> // for standard headers #include <algorithm> std::array<int,5> a; std::default_random_engine e; std::uniform_int_distribution<int> dist(1, 6); std::generate_n(a.begin(), a.size(), [&](){ return dist(e); }); std::sort(a.begin(), a.end()); std::find(a.begin(), a.end(), 123)
84 Using the standard library #include <array> // note the angular brackets #include <random> // for standard headers #include <algorithm> std::array<int,5> a; std::default_random_engine e; std::uniform_int_distribution<int> dist(1, 6); std::generate_n(a.begin(), a.size(), [&](){ return dist(e); }); std::sort(a.begin(), a.end()); if (std::find(a.begin(), a.end(), 123) == a.end()) { // 123 not found in a }
85 std::vector The default container Similar to an array, but adjusts its size dynamically std::vector<int> v; // size is 0 v.push_back(123); // size is 1... v[42]; std::array<int,5> a; std::vector<int> v(5);
86 std::vector The default container Similar to an array, but adjusts its size dynamically Inserting/removing at the end is O(1) Inserting/removing in the middle is O(n) Access to the i th element is O(1) std::vector<int> v; // size is 0 v.push_back(123); // size is 1... v[42]; std::array<int,5> a; std::vector<int> v(5);
87 std::vector The default container Similar to an array, but adjusts its size dynamically Inserting/removing at the end is O(1) Inserting/removing in the middle is O(n) Access to the i th element is O(1) std::vector<int> v; // size is 0 v.push_back(123); // size is 1... v[42]; std::array<int,5> a; std::vector<int> v(5); std::default_random_engine e; std::uniform_int_distribution<int> dist(1, 6); std::generate_n(v.begin(), v.size(), [&](){ return dist(e); }); std::sort(v.begin(), v.end()); if (std::find(v.begin(), v.end(), 123) == v.end()) { // 123 not found in v }
88 std::list Bi-directional list Node-based, scattered in memory std::list<int> l; v.push_back(123); v.push_front(456);... *std::next(l.begin(), 42);
89 std::list Bi-directional list Node-based, scattered in memory Inserting/removing is always O(1) Access to the i th element is O(n) std::list<int> l; v.push_back(123); v.push_front(456);... *std::next(l.begin(), 42);
90 std::list Bi-directional list Node-based, scattered in memory Inserting/removing is always O(1) Access to the i th element is O(n) std::list<int> l; v.push_back(123); v.push_front(456);... *std::next(l.begin(), 42); std::default_random_engine e; std::uniform_int_distribution<int> dist(1, 6); std::generate_n(l.begin(), l.size(), [&](){ return dist(e); }); std::sort(l.begin(), l.end()); if (std::find(l.begin(), l.end(), 123) == l.end()) { // 123 not found in l }
91 std::list Bi-directional list Node-based, scattered in memory Inserting/removing is always O(1) Access to the i th element is O(n) std::list<int> l; v.push_back(123); v.push_front(456);... *std::next(l.begin(), 42); std::default_random_engine e; std::uniform_int_distribution<int> dist(1, 6); std::generate_n(l.begin(), l.size(), [&](){ return dist(e); }); std::sort(l.begin(), l.end()); // error if (std::find(l.begin(), l.end(), 123) == l.end()) { // 123 not found in l }
92 std::list Bi-directional list Node-based, scattered in memory Inserting/removing is always O(1) Access to the i th element is O(n) std::list<int> l; v.push_back(123); v.push_front(456);... *std::next(l.begin(), 42); std::default_random_engine e; std::uniform_int_distribution<int> dist(1, 6); std::generate_n(l.begin(), l.size(), [&](){ return dist(e); }); l.sort(); if (std::find(l.begin(), l.end(), 123) == l.end()) { // 123 not found in l }
93 Function objects A mechanism to define something-callable-like-a-function
94 Function objects A mechanism to define something-callable-like-a-function auto cat( string const& s, int i ) { return s to_string(i); } auto s = cat("xy", 5); // XY-5
95 Function objects A mechanism to define something-callable-like-a-function auto cat( string const& s, int i ) { return s to_string(i); } auto s = cat("xy", 5); // XY-5 vector<int> v{2,3,5}; auto s = accumulate( begin(v), end(v), string{"xy"}, cat ); // XY-2-3-5
96 Function objects A mechanism to define something-callable-like-a-function A class with anoperator() auto cat( string const& s, int i ) { return s to_string(i); } struct Cat { auto operator() ( string const& s, int i ) const { return s to_string(i); } }; auto s = cat("xy", 5); // XY-5 vector<int> v{2,3,5}; auto s = accumulate( begin(v), end(v), string{"xy"}, cat ); // XY-2-3-5
97 Function objects A mechanism to define something-callable-like-a-function A class with anoperator() auto cat( string const& s, int i ) { return s to_string(i); } auto s = cat("xy", 5); // XY-5 struct Cat { auto operator() ( string const& s, int i ) const { return s to_string(i); } }; Cat cat{}; vector<int> v{2,3,5}; auto s = accumulate( begin(v), end(v), string{"xy"}, cat ); // XY-2-3-5
98 Function objects A mechanism to define something-callable-like-a-function A class with anoperator() auto cat( string const& s, int i ) { return s to_string(i); } auto s = cat("xy", 5); // XY-5 struct Cat { auto operator() ( string const& s, int i ) const { return s to_string(i); } }; Cat cat; vector<int> v{2,3,5}; auto s = accumulate( begin(v), end(v), string{"xy"}, cat ); // XY-2-3-5
99 Function objects A mechanism to define something-callable-like-a-function A class with anoperator() auto cat( string const& s, int i ) { return s to_string(i); } auto s = cat("xy", 5); // XY-5 struct Cat { auto operator() ( string const& s, int i ) const { return s to_string(i); } }; Cat cat; auto s = cat("xy", 5); // XY-5 vector<int> v{2,3,5}; auto s = accumulate( begin(v), end(v), string{"xy"}, cat ); // XY-2-3-5
100 Function objects A mechanism to define something-callable-like-a-function A class with anoperator() auto cat( string const& s, int i ) { return s to_string(i); } auto s = cat("xy", 5); // XY-5 vector<int> v{2,3,5}; auto s = accumulate( begin(v), end(v), string{"xy"}, cat ); // XY struct Cat { auto operator() ( string const& s, int i ) const { return s to_string(i); } }; Cat cat; auto s = cat("xy", 5); // XY-5 vector<int> v{2,3,5}; auto s = accumulate( begin(v), end(v), string{"xy"}, cat ); // XY-2-3-5
101 Function objects A mechanism to define something-callable-like-a-function A class with anoperator() auto cat( string const& s, int i ) { return s to_string(i); } auto s = cat("xy", 5); // XY-5 vector<int> v{2,3,5}; auto s = accumulate( begin(v), end(v), string{"xy"}, cat ); // XY struct Cat { auto operator() ( string const& s, int i ) const { return s to_string(i); } }; Cat cat; auto s = Cat{}("XY", 5); // XY-5 vector<int> v{2,3,5}; auto s = accumulate( begin(v), end(v), string{"xy"}, cat ); // XY-2-3-5
102 Function objects A mechanism to define something-callable-like-a-function A class with anoperator() auto cat( string const& s, int i ) { return s to_string(i); } auto s = cat("xy", 5); // XY-5 vector<int> v{2,3,5}; auto s = accumulate( begin(v), end(v), string{"xy"}, cat ); // XY struct Cat { auto operator() ( string const& s, int i ) const { return s to_string(i); } }; Cat cat; auto s = Cat{}("XY", 5); // XY-5 vector<int> v{2,3,5}; auto s = accumulate( begin(v), end(v), string{"xy"}, Cat{} ); // XY-2-3-5
103 Function objects A function object, being the instance of a class, can have state
104 Function objects A function object, being the instance of a class, can have state class CatWithState { char c_; public: explicit CatWithState(char c) : c_{c} {} auto operator()(string const& s, int i) const { return s + c_ + to_string(i); } };
105 Function objects A function object, being the instance of a class, can have state class CatWithState { char c_; public: explicit CatWithState(char c) : c_{c} {} auto operator()(string const& s, int i) const { return s + c_ + to_string(i); } }; CatWithState cat1{ - }; auto s1 = cat1("xy", 5); // XY-5
106 Function objects A function object, being the instance of a class, can have state class CatWithState { char c_; public: explicit CatWithState(char c) : c_{c} {} auto operator()(string const& s, int i) const { return s + c_ + to_string(i); } }; CatWithState cat1{ - }; auto s1 = cat1("xy", 5); // XY-5 CatWithState cat2{ + }; auto s2 = cat2("xy", 5); // XY+5
107 Function objects A function object, being the instance of a class, can have state class CatWithState { char c_; public: explicit CatWithState(char c) : c_{c} {} auto operator()(string const& s, int i) const { return s + c_ + to_string(i); } }; CatWithState cat1{ - }; auto s1 = cat1("xy", 5); // XY-5 CatWithState cat2{ + }; auto s2 = cat2("xy", 5); // XY+5 vector<int> v{2,3,5}; auto s3 = accumulate(..., cat1); // XY auto s4 = accumulate(..., cat2); // XY+2+3+5
108 Function objects A function object, being the instance of a class, can have state class CatWithState { char c_; public: explicit CatWithState(char c) : c_{c} {} auto operator()(string const& s, int i) const { return s + c_ + to_string(i); } }; CatWithState cat1{ - }; auto s1 = CatWithState{ - }("XY", 5); // XY-5 CatWithState cat2{ + }; auto s2 = CatWithState{ + }("XY", 5); // XY+5 vector<int> v{2,3,5}; auto s3 = accumulate(..., CatWithState{ - }); // XY auto s4 = accumulate(..., CatWithState{ + }); // XY+2+3+5
109 Function objects (cont.) An example from the standard library #include <random> // random bit generator (mersenne twister) std::mt19937 gen; // generate N 32-bit unsigned integer numbers for (int n = 0; n!= N; ++n) { std::cout << gen() << \n ; } // generate N floats distributed normally (mean: 0., stddev: 1.) std::normal_distribution<float> dist; for (int n = 0; n!= N; ++n) { std::cout << dist(gen) << \n ; } // generate N ints distributed uniformly between 1 and 6 included std::uniform_int_distribution<> roll_dice(1, 6); for (int n = 0; n!= N; ++n) { std::cout << roll_dice(gen) << \n ; }
110 Lambda expression A concise way to create an unnamed function object Useful to pass actions/callbacks to algorithms, threads, frameworks,...
111 Lambda expression A concise way to create an unnamed function object Useful to pass actions/callbacks to algorithms, threads, frameworks,... struct Cat { auto operator()( string const& s, int i ) const { return s to_string(i); } }; class CatWithState { char c_; public: explicit CatWithState(char c) : c_{c} {} auto operator() (string const& s, int i) const {return s + c_ + to_string(i);} }; accumulate(..., Cat{}); accumulate(...,catwithstate{ - });
112 Lambda expression A concise way to create an unnamed function object Useful to pass actions/callbacks to algorithms, threads, frameworks,... struct Cat { auto operator()( string const& s, int i ) const { return s to_string(i); } }; class CatWithState { char c_; public: explicit CatWithState(char c) : c_{c} {} auto operator() (string const& s, int i) const {return s + c_ + to_string(i);} }; accumulate(..., Cat{}); accumulate(..., [](string const& s, int i) { return s to_string(i); } ); accumulate(...,catwithstate{ - });
113 Lambda expression A concise way to create an unnamed function object Useful to pass actions/callbacks to algorithms, threads, frameworks,... struct Cat { auto operator()( string const& s, int i ) const { return s to_string(i); } }; class CatWithState { char c_; public: explicit CatWithState(char c) : c_{c} {} auto operator() (string const& s, int i) const {return s + c_ + to_string(i);} }; accumulate(..., Cat{}); accumulate(..., [](string const& s, int i) { return s to_string(i); } ); accumulate(...,catwithstate{ - }); char c{ - }; accumulate(..., [=](string const& s, int i) { return s + c + to_string(i); } );
114 Lambda expression (cont.) The evaluation of a lambda expression produces an unnamed function object (a closure) Theoperator() corresponds to the code of the body of the lambda expression The data members are the captured local variables
115 Lambda expression (cont.) The evaluation of a lambda expression produces an unnamed function object (a closure) Theoperator() corresponds to the code of the body of the lambda expression The data members are the captured local variables class SomeUniqueName { auto l = [] public: explicit SomeUniqueName( ) {} auto operator() }; auto l = SomeUniqueName{ };
116 Lambda expression (cont.) The evaluation of a lambda expression produces an unnamed function object (a closure) Theoperator() corresponds to the code of the body of the lambda expression The data members are the captured local variables class SomeUniqueName { auto l = [](int i) { return i + v; } public: explicit SomeUniqueName( ) {} auto operator()(int i) { return i + v ; } }; auto l = SomeUniqueName{ };
117 Lambda expression (cont.) The evaluation of a lambda expression produces an unnamed function object (a closure) Theoperator() corresponds to the code of the body of the lambda expression The data members are the captured local variables int v = 3; auto l = [](int i) { return i + v; } class SomeUniqueName { public: explicit SomeUniqueName( ) {} auto operator()(int i) { return i + v ; } }; int v = 3; auto l = SomeUniqueName{ };
118 Lambda expression (cont.) The evaluation of a lambda expression produces an unnamed function object (a closure) Theoperator() corresponds to the code of the body of the lambda expression The data members are the captured local variables int v = 3; auto l = [=](int i) { return i + v; } class SomeUniqueName { int v_; public: explicit SomeUniqueName(int v) : v_{v} {} auto operator()(int i) { return i + v_; } }; int v = 3; auto l = SomeUniqueName{v};
119 Lambda expression (cont.) The evaluation of a lambda expression produces an unnamed function object (a closure) Theoperator() corresponds to the code of the body of the lambda expression The data members are the captured local variables int v = 3; auto l = [=](int i) { return i + v; } auto r = l(5); // 8 class SomeUniqueName { int v_; public: explicit SomeUniqueName(int v) : v_{v} {} auto operator()(int i) { return i + v_; } }; int v = 3; auto l = SomeUniqueName{v}; auto r = l(5); // 8
120 Lambda expression (cont.) The evaluation of a lambda expression produces an unnamed function object (a closure) Theoperator() corresponds to the code of the body of the lambda expression The data members are the captured local variables auto l = [v = 3](int i) { return i + v; } auto r = l(5); // 8 class SomeUniqueName { int v_; public: explicit SomeUniqueName(int v) : v_{v} {} auto operator()(int i) { return i + v_; } }; int v = 3; auto l = SomeUniqueName{v}; auto r = l(5); // 8
121 Lambda expression (cont.) The evaluation of a lambda expression produces an unnamed function object (a closure) Theoperator() corresponds to the code of the body of the lambda expression The data members are the captured local variables auto l = [v = 3](int i) -> int { return i + v; } auto r = l(5); // 8 class SomeUniqueName { int v_; public: explicit SomeUniqueName(int v) : v_{v} {} int operator()(int i) { return i + v_; } }; int v = 3; auto l = SomeUniqueName{v}; auto r = l(5); // 8
122 Lambda: capturing Automatic variables used in the body need to be captured [] capture nothing [=] capture all by value [k] capturekby value [&] capture all by reference [&k] capture k by reference [=, &k] capture all by value butkby reference [&, k] capture all by reference butkby value
123 Lambda: capturing Automatic variables used in the body need to be captured [] capture nothing [=] capture all by value [k] capturekby value [&] capture all by reference [&k] capture k by reference [=, &k] capture all by value butkby reference [&, k] capture all by reference butkby value int v = 3; auto l = [v] {}; class SomeUniqueName { int v_; public: explicit SomeUniqueName(int v) : v_v {}... }; auto l = SomeUniqueName{v};
124 Lambda: capturing Automatic variables used in the body need to be captured [] capture nothing [=] capture all by value [k] capturekby value [&] capture all by reference [&k] capture k by reference [=, &k] capture all by value butkby reference [&, k] capture all by reference butkby value int v = 3; auto l = [&v] {}; class SomeUniqueName { int& v_; public: explicit SomeUniqueName(int& v) : v_v {}... }; auto l = SomeUniqueName{v};
125 Lambda: capturing Automatic variables used in the body need to be captured [] capture nothing [=] capture all by value [k] capturekby value [&] capture all by reference [&k] capture k by reference [=, &k] capture all by value butkby reference [&, k] capture all by reference butkby value int v = 3; auto l = [&v] {}; class SomeUniqueName { int& v_; public: explicit SomeUniqueName(int& v) : v_v {}... }; auto l = SomeUniqueName{v}; Global variables are available without being captured
126 Lambda: const and mutable By default the call to a lambda isconst Variable captured by value are not modifiable [] {}; struct SomeUniqueName { auto operator()() const {} };
127 Lambda: const and mutable By default the call to a lambda isconst Variable captured by value are not modifiable A lambda can be declaredmutable []() mutable {}; struct SomeUniqueName { auto operator()() {} };
128 Lambda: const and mutable By default the call to a lambda isconst Variable captured by value are not modifiable A lambda can be declaredmutable []() mutable -> void {}; struct SomeUniqueName { void operator()() {} };
129 Lambda: const and mutable By default the call to a lambda isconst Variable captured by value are not modifiable A lambda can be declaredmutable []() mutable -> void {}; struct SomeUniqueName { void operator()() {} }; Variables captured by reference can be modified There is no way to capture byconst& int v = 3; [&v] { ++v; }(); assert(v == 4);
130 Lambda: dangling reference Be careful not to have dangling references in a closure It s similar to a function returning a reference to a local variable auto make_lambda() { int v = 3; return [&] { return v; }; // return a closure } auto l = make_lambda(); auto d = l(); // the captured variable is dangling here auto start_in_thread() { int v = 3; return std::async([&] { return v; }); }
131 std::function Type-erased wrapper that can store and invoke any callable entity with a certain signature function, function object, lambda, member function Some space and time overhead, so use only if a template parameter is not satisfactory
132 std::function Type-erased wrapper that can store and invoke any callable entity with a certain signature function, function object, lambda, member function Some space and time overhead, so use only if a template parameter is not satisfactory #include <functional> int sum_squares(int x, int y) { return x * x + y * y; } int main() { std::vector<std::function<int(int, int)>> v { std::plus<>{}, // has a compatible operator() std::multiplies<>{}, // idem &sum_squares) }; for (int k = 10; k <= 1000; k *= 10) { v.push_back([k](int x, int y) -> int { return k * x + y; }); } for (auto const& f : v) { std::cout << f(4, 5) << \n ; } }
133 Smart pointers and custom deleters unique_ptr andshared_ptr can be used as general-purpose resource handlers The resource release is not necessarily done withdelete unique_ptr andshared_ptr support a custom deleter
134 Smart pointers and custom deleters unique_ptr andshared_ptr can be used as general-purpose resource handlers The resource release is not necessarily done withdelete unique_ptr andshared_ptr support a custom deleter FILE* f = std::fopen(...);... std::fclose(f);
135 Smart pointers and custom deleters unique_ptr andshared_ptr can be used as general-purpose resource handlers The resource release is not necessarily done withdelete unique_ptr andshared_ptr support a custom deleter FILE* f = std::fopen(...);... std::fclose(f); Usual problems: Who owns the resource? Forgetting to release Releasing twice Early return/throw
136 Smart pointers and custom deleters unique_ptr andshared_ptr can be used as general-purpose resource handlers The resource release is not necessarily done withdelete unique_ptr andshared_ptr support a custom deleter FILE* f = std::fopen(...);... std::fclose(f); Usual problems: Who owns the resource? Forgetting to release Releasing twice Early return/throw auto s = std::shared_ptr<file>{ std::fopen(...), std::fclose };
137 Smart pointers and custom deleters unique_ptr andshared_ptr can be used as general-purpose resource handlers The resource release is not necessarily done withdelete unique_ptr andshared_ptr support a custom deleter FILE* f = std::fopen(...);... std::fclose(f); Usual problems: Who owns the resource? Forgetting to release Releasing twice Early return/throw auto s = std::shared_ptr<file>{ std::fopen(...), std::fclose }; auto u = std::unique_ptr< FILE, int(*)(file*) >{ std::fopen(...), &std::fclose };
138 Smart pointers and custom deleters unique_ptr andshared_ptr can be used as general-purpose resource handlers The resource release is not necessarily done withdelete unique_ptr andshared_ptr support a custom deleter FILE* f = std::fopen(...);... std::fclose(f); Usual problems: Who owns the resource? Forgetting to release Releasing twice Early return/throw auto s = std::shared_ptr<file>{ std::fopen(...), std::fclose }; auto u = std::unique_ptr< FILE, decltype(&std::fclose) >{ std::fopen(...), &std::fclose };
139 Smart pointers and custom deleters unique_ptr andshared_ptr can be used as general-purpose resource handlers The resource release is not necessarily done withdelete unique_ptr andshared_ptr support a custom deleter FILE* f = std::fopen(...);... std::fclose(f); Usual problems: Who owns the resource? Forgetting to release Releasing twice Early return/throw auto s = std::shared_ptr<file>{ std::fopen(...), std::fclose }; auto u = std::unique_ptr< FILE, std::function<int(file*)> >{ std::fopen(...), std::fclose };
140 Smart pointers and custom deleters unique_ptr andshared_ptr can be used as general-purpose resource handlers The resource release is not necessarily done withdelete unique_ptr andshared_ptr support a custom deleter FILE* f = std::fopen(...);... std::fclose(f); Usual problems: Who owns the resource? Forgetting to release Releasing twice Early return/throw auto s = std::shared_ptr<file>{ std::fopen(...), std::fclose }; auto u = std::unique_ptr< FILE, std::function<void(file*)> >{ std::fopen(...), std::fclose };
141 Smart pointers and custom deleters unique_ptr andshared_ptr can be used as general-purpose resource handlers The resource release is not necessarily done withdelete unique_ptr andshared_ptr support a custom deleter FILE* f = std::fopen(...);... std::fclose(f); Usual problems: Who owns the resource? Forgetting to release Releasing twice Early return/throw auto s = std::shared_ptr<file>{ std::fopen(...), std::fclose }; auto u = std::unique_ptr< FILE, std::function<void(file*)> >{ std::fopen(...), [](FILE* f){ std::fclose(f); } };
142 Smart pointers and custom deleters unique_ptr andshared_ptr can be used as general-purpose resource handlers The resource release is not necessarily done withdelete unique_ptr andshared_ptr support a custom deleter FILE* f = std::fopen(...);... std::fclose(f); Usual problems: Who owns the resource? Forgetting to release Releasing twice Early return/throw auto s = std::shared_ptr<file>{ std::fopen(...), std::fclose }; auto u = std::unique_ptr< FILE, std::function<void(file*)> >{ std::fopen(...), [](auto f){ std::fclose(f); } };
143 Hands-on Starting fromalgo.cpp, write code to sum all the elements of the vector multiply all the elements of the vector sort the vector in ascending and descending order move the even numbers to the beginning move the three central numbers to the beginning erase from the vector the elements that satisfy a predicate...
Efficient C++ Programming and Memory Management
Efficient C++ Programming and Memory Management F. Giacomini INFN-CNAF ESC 17 Bertinoro, 22-28 October 2017 https://baltig.infn.it/giaco/cpp-memory-esc17 Outline Introduction Type deduction Function, function
use static size for this buffer
Software Design (C++) 4. Templates and standard library (STL) Juha Vihavainen University of Helsinki Overview Introduction to templates (generics) std::vector again templates: specialization by code generation
Boost.Compute. A C++ library for GPU computing. Kyle Lutz
Boost.Compute A C++ library for GPU computing Kyle Lutz GPUs (NVIDIA, AMD, Intel) Multi-core CPUs (Intel, AMD) STL for Parallel Devices Accelerators (Xeon Phi, Adapteva Epiphany) FPGAs (Altera, Xilinx)
Major Language Changes, pt. 1
C++0x What is C++0x? Updated version of C++ language. Addresses unresolved problems in C++03. Almost completely backwards compatible. Greatly increases expressiveness (and complexity!) of language. Greatly
Lecture 21 Standard Template Library. A simple, but very limited, view of STL is the generality that using template functions provides.
Lecture 21 Standard Template Library STL: At a C++ standards meeting in 1994, the committee voted to adopt a proposal by Alex Stepanov of Hewlett-Packard Laboratories to include, as part of the standard
Working Draft, Technical Specification for C++ Extensions for Parallelism, Revision 1
Document Number: N3960 Date: 2014-02-28 Reply to: Jared Hoberock NVIDIA Corporation jhoberock@nvidia.com Working Draft, Technical Specification for C++ Extensions for Parallelism, Revision 1 Note: this
To use various types of iterators with the STL algorithms ( ). To use Boolean functions to specify criteria for STL algorithms ( 23.8).
CHAPTER 23 STL Algorithms Objectives To use various types of iterators with the STL algorithms ( 23.1 23.20). To discover the four types of STL algorithms: nonmodifying algorithms, modifying algorithms,
Functors. Cristian Cibils
Functors Cristian Cibils (ccibils@stanford.edu) Administrivia You should have Evil Hangman feedback on paperless. If it is there, you received credit Functors Let's say that we needed to find the number
Programming Languages Technical Specification for C++ Extensions for Parallelism
ISO 05 All rights reserved ISO/IEC JTC SC WG N4409 Date: 05-04-0 ISO/IEC DTS 9570 ISO/IEC JTC SC Secretariat: ANSI Programming Languages Technical Specification for C++ Extensions for Parallelism Warning
C++ Modern and Lucid C++ for Professional Programmers
Informatik C++ Modern and Lucid C++ for Professional Programmers part 9 Prof. Peter Sommerlad Institutsleiter IFS Institute for Software Rapperswil, HS 2015 Functors and Parameterizing STL Functors, Lambdas,
Parallelism in C++ J. Daniel Garcia. Universidad Carlos III de Madrid. November 23, 2018
J. Daniel Garcia Universidad Carlos III de Madrid November 23, 2018 cbea J. Daniel Garcia ARCOS@UC3M (josedaniel.garcia@uc3m.es) 1/58 Introduction to generic programming 1 Introduction to generic programming
STL components. STL: C++ Standard Library Standard Template Library (STL) Main Ideas. Components. Encapsulates complex data structures and algorithms
STL: C++ Standard Library Standard Template Library (STL) Encapsulates complex data structures and algorithms is a library of generic container classes which are both efficient and functional C++ STL developed
Advanced C ++ Philip Blakely. Laboratory for Scientific Computing, University of Cambridge. Philip Blakely (LSC) Advanced C++ 1 / 119
Advanced C ++ Philip Blakely Laboratory for Scientific Computing, University of Cambridge Philip Blakely (LSC) Advanced C++ 1 / 119 Part I C ++ 11 Philip Blakely (LSC) Advanced C++ 2 / 119 C ++ 11 C ++
Introduction to GIL, Boost and Generic Programming
Introduction to GIL, Boost and Generic Programming Hailin Jin Advanced Technology Labs Adobe Systems Incorporated http://www.adobe.com/technology/people/sanjose/jin.html 1 Outline GIL Boost Generic programming
ESC'15 Bertinoro, October Efficient C++ Coding. Francesco Giacomini INFN
ESC'15 Bertinoro, 25 31 October 2015 Efficient C++ Coding Francesco Giacomini INFN Introduction C++ is a complex and large language (and library) The following material only scratches the surface If you
12. Dictionaries. Dictionary. Idea. Other idea
Dictionary 12. Dictionaries Dictionary, Self-ordering List, Implementation of Dictionaries with Array / List /Sip lists. [Ottman/Widmayer, Kap. 3.3,1.7, Cormen et al, Kap. Problem 17-5] ADT to manage eys
Working Draft, Technical Specification for C++ Extensions for Parallelism
Document Number: N3850 Date: 2014-01-17 Reply to: Jared Hoberock NVIDIA Corporation jhoberock@nvidia.com Working Draft, Technical Specification for C++ Extensions for Parallelism Note: this is an early
When we program, we have to deal with errors. Our most basic aim is correctness, but we must
Chapter 5 Errors When we program, we have to deal with errors. Our most basic aim is correctness, but we must deal with incomplete problem specifications, incomplete programs, and our own errors. When
CS11 Advanced C++ Spring 2018 Lecture 2
CS11 Advanced C++ Spring 2018 Lecture 2 Lab 2: Completing the Vector Last week, got the basic functionality of our Vector template working It is still missing some critical functionality Iterators are
STL Quick Reference for CS 241
STL Quick Reference for CS 241 Spring 2018 The purpose of this document is to provide basic information on those elements of the C++14 standard library we think are most likely to be needed in CS 241.
C++ for numerical computing - part 2
C++ for numerical computing - part 2 Rupert Nash r.nash@epcc.ed.ac.uk 1 / 36 Recap 2 / 36 Iterators std::vector data = GetData(n); // C style iteration - fully explicit for (auto i=0; i!= n; ++i)
TDDD38 - Advanced programming in C++
TDDD38 - Advanced programming in C++ STL II Christoffer Holm Department of Computer and information science 1 Iterators 2 Associative Containers 3 Container Adaptors 4 Lambda Functions 1 Iterators 2 Associative
Parallelism and Concurrency in C++17 and C++20. Rainer Grimm Training, Coaching and, Technology Consulting
Parallelism and Concurrency in C++17 and C++20 Rainer Grimm Training, Coaching and, Technology Consulting www.grimm-jaud.de Multithreading and Parallelism in C++ Multithreading in C++17 Parallel STL The
/ binary_search example #include <iostream> // std::cout #include <algorithm> // std::binary_search, std::sort #include <vector> // std::vector
Algorithm Searching Example find, search, binary search / binary_search example #include // std::cout #include // std::binary_search, std::sort #include // std::vector bool
Standard Template Library. Containers, Iterators, Algorithms. Sequence Containers. Containers
Standard Template Library The standard template library (STL) contains Containers Algorithms Iterators A container is a way that stored data is organized in memory, for example an array of elements. Algorithms
Object-Oriented Programming for Scientific Computing
Object-Oriented Programming for Scientific Computing Traits and Policies Ole Klein Interdisciplinary Center for Scientific Computing Heidelberg University ole.klein@iwr.uni-heidelberg.de Summer Semester
STL. Zoltán Porkoláb: C++11/14 1
STL Generic programming An example inserters, iterator-adapters, functors Efficiency Memory consuption characteristics Std::array Forward_list Unordered containers in C++11 Zoltán Porkoláb: C++11/14 1
COEN244: Class & function templates
COEN244: Class & function templates Aishy Amer Electrical & Computer Engineering Templates Function Templates Class Templates Outline Templates and inheritance Introduction to C++ Standard Template Library
Lambdas in unevaluated contexts
Lambdas in unevaluated contexts Document #: P0315R1 Date: 2016-08-01 Project: Programming Language C++ Evolution Group Reply-to: Louis Dionne 1 Revision history R0 Initial draft R1
C++11 and Compiler Update
C++11 and Compiler Update John JT Thomas Sr. Director Application Developer Products About this Session A Brief History Features of C++11 you should be using now Questions 2 Bjarne Stroustrup C with Objects
The Standard Template Library. An introduction
1 The Standard Template Library An introduction 2 Standard Template Library (STL) Objective: Reuse common code Common constructs: Generic containers and algorithms STL Part of the C++ Standard Library
Lambda functions. Zoltán Porkoláb: C++11/14 1
Lambda functions Terminology How it is compiled Capture by value and reference Mutable lambdas Use of this Init capture and generalized lambdas in C++14 Constexpr lambda and capture *this and C++17 Zoltán
The Standard Template Library. EECS 211 Winter 2018
The Standard Template Library EECS 211 Winter 2018 2 Problem: finding the maximum element of a vector A simple fixed-size vector struct: struct Int_vec int* data; size_t size; ; 3 Solution: max_int_vec
Exercise 6.2 A generic container class
Exercise 6.2 A generic container class The goal of this exercise is to write a class Array that mimics the behavior of a C++ array, but provides more intelligent memory management a) Start with the input
A Parallel Algorithms Library N3724
A Parallel Algorithms Library N3724 Jared Hoberock Jaydeep Marathe Michael Garland Olivier Giroux Vinod Grover {jhoberock, jmarathe, mgarland, ogiroux, vgrover}@nvidia.com Artur Laksberg Herb Sutter {arturl,
Database Systems on Modern CPU Architectures
Database Systems on Modern CPU Architectures Introduction to Modern C++ Moritz Sichert Technische Universität München Department of Informatics Chair of Data Science and Engineering Overview Prerequisites:
19. Dynamic Data Structures II
Different Memory Layout: Linked List 19. Dynamic Data Structures II Linked Lists, Vectors as Linked Lists No contiguous area of memory and no random access Each element points to its successor Insertion
CS11 Advanced C++ Fall Lecture 1
CS11 Advanced C++ Fall 2006-2007 Lecture 1 Welcome! ~8 lectures Slides are posted on CS11 website http://www.cs.caltech.edu/courses/cs11 ~6 lab assignments More involved labs 2-3 week project at end CS
Lambdas in unevaluated contexts
Lambdas in unevaluated contexts Document #: P0315R2 Date: 2017-06-18 Project: Programming Language C++ Audience: Core Working Group Reply-to: Louis Dionne Hubert Tong
Part XI. Algorithms and Templates. Philip Blakely (LSC) C++ Introduction 314 / 370
Part XI Algorithms and Templates Philip Blakely (LSC) C++ Introduction 314 / 370 STL Algorithms Outline 44 STL Algorithms 45 Templates 46 Summing an array 47 Templated classes Philip Blakely (LSC) C++
STL: C++ Standard Library
STL: C++ Standard Library Encapsulates complex data structures and algorithms CSC 330 OO Software Design 1 We ve emphasized the importance of software reuse. Recognizing that many data structures and algorithms
Computer Science II Lecture 2 Strings, Vectors and Recursion
1 Overview of Lecture 2 Computer Science II Lecture 2 Strings, Vectors and Recursion The following topics will be covered quickly strings vectors as smart arrays Basic recursion Mostly, these are assumed
Chapter 5. The Standard Template Library.
Object-oriented programming B, Lecture 11e. 1 Chapter 5. The Standard Template Library. 5.1. Overview of main STL components. The Standard Template Library (STL) has been developed by Alexander Stepanov,
What will happen if we try to compile, link and run this program? Do you have any comments to the code?
1 # include < iostream > 2 3 int main () 4 { 5 std :: cout
Stream Computing using Brook+
Stream Computing using Brook+ School of Electrical Engineering and Computer Science University of Central Florida Slides courtesy of P. Bhaniramka Outline Overview of Brook+ Brook+ Software Architecture
Modern and Lucid C++ for Professional Programmers. Part 7 Standard Containers & Iterators. Department I - C Plus Plus
Department I - C Plus Plus Modern and Lucid C++ for Professional Programmers Part 7 Standard Containers & Iterators Prof. Peter Sommerlad / Thomas Corbat Rapperswil, 8.11.2017 HS2017 STL Containers: General
September 10,
September 10, 2013 1 Bjarne Stroustrup, AT&T Bell Labs, early 80s cfront original C++ to C translator Difficult to debug Potentially inefficient Many native compilers exist today C++ is mostly upward compatible
CSCI-1200 Data Structures Fall 2018 Lecture 22 Hash Tables, part 2 & Priority Queues, part 1
Review from Lecture 21 CSCI-1200 Data Structures Fall 2018 Lecture 22 Hash Tables, part 2 & Priority Queues, part 1 the single most important data structure known to mankind Hash Tables, Hash Functions,
Outline. 1 About the course
Outline EDAF50 C++ Programming 1. Introduction 1 About the course Sven Gestegård Robertz Computer Science, LTH 2018 2 Presentation of C++ History Introduction Data types and variables 1. Introduction 2/1
Introduction to C++11 and its use inside Qt
Introduction to C++11 and its use inside Qt Olivier Goffart February 2013 1/43 Introduction to C++11 and its use inside Qt About Me http://woboq.com http://code.woboq.org 2/43 Introduction to C++11 and
Unit 1: Preliminaries Part 4: Introduction to the Standard Template Library
Unit 1: Preliminaries Part 4: Introduction to the Standard Template Library Engineering 4892: Data Structures Faculty of Engineering & Applied Science Memorial University of Newfoundland May 6, 2010 ENGI
G52CPP C++ Programming Lecture 18
G52CPP C++ Programming Lecture 18 Dr Jason Atkin http://www.cs.nott.ac.uk/~jaa/cpp/ g52cpp.html 1 Welcome Back 2 Last lecture Operator Overloading Strings and streams 3 Operator overloading - what to know
CSCI-1200 Data Structures Fall 2017 Lecture 2 STL Strings & Vectors
Announcements CSCI-1200 Data Structures Fall 2017 Lecture 2 STL Strings & Vectors HW 1 is available on-line through the website (on the Calendar ). Be sure to read through this information as you start
Advanced C++ STL. Tony Wong
Tony Wong 2017-03-25 C++ Standard Template Library Algorithms Sorting Searching... Data structures Dynamically-sized array Queues... The implementation is abstracted away from the users The implementation
COMP6771 Advanced C++ Programming
1........ COMP6771 Advanced C++ Programming Week 4 Part Three: Function Objects and 2016 www.cse.unsw.edu.au/ cs6771 2........ Converting Class Types to bool Convenient to use a class object as bool to
Templates. Giuseppe Lipari Scuola Superiore Sant Anna Pisa. June 8, 2009
Templates Giuseppe Lipari http://retis.sssup.it Scuola Superiore Sant Anna Pisa June 8, 2009 Reuse One of the most important keywords in OO programming is code reuse If you have a piece of code that works
CSCI-1200 Data Structures Spring 2015 Lecture 2 STL Strings & Vectors
Announcements CSCI-1200 Data Structures Spring 2015 Lecture 2 STL Strings & Vectors HW 1 is available on-line through the website (on the Calendar ). Be sure to read through this information as you start
COMP6771 Advanced C++ Programming
1.. COMP6771 Advanced C++ Programming Week 5 Part Two: Dynamic Memory Management 2016 www.cse.unsw.edu.au/ cs6771 2.. Revisited 1 #include 2 3 struct X { 4 X() { std::cout
Introduction to C++ Systems Programming
Introduction to C++ Systems Programming Introduction to C++ Syntax differences between C and C++ A Simple C++ Example C++ Input/Output C++ Libraries C++ Header Files Another Simple C++ Example Inline Functions
Concurrency and Parallelism with C++17 and C++20. Rainer Grimm Training, Coaching and, Technology Consulting
Concurrency and Parallelism with C++17 and C++20 Rainer Grimm Training, Coaching and, Technology Consulting www.modernescpp.de Concurrency and Parallelism in C++ Concurrency and Parallelism in C++17 Parallel
MODULE 37 --THE STL-- ALGORITHM PART V
MODULE 37 --THE STL-- ALGORITHM PART V My Training Period: hours Note: Compiled using Microsoft Visual C++.Net, win32 empty console mode application. g++ compilation example is given at the end of this
I source_beg, source_end; // defines a range of values in a source container // defines the beginning of a range in a destination container
Generic Algorithms We have encountered and put to use the concept of generic classes, particularly generic containers. Generic containers could be characterized as implementations of ADTs that are re usable
Chapter 15 - C++ As A "Better C"
Chapter 15 - C++ As A "Better C" Outline 15.1 Introduction 15.2 C++ 15.3 A Simple Program: Adding Two Integers 15.4 C++ Standard Library 15.5 Header Files 15.6 Inline Functions 15.7 References and Reference
CSCI 102L - Data Structures Midterm Exam #2 Spring 2011
CSCI 102L - Data Structures Midterm Exam #2 Spring 2011 (12:30pm - 1:50pm, Thursday, March 24) Instructor: Bill Cheng ( This exam is closed book, closed notes, closed everything. No cheat sheet allowed.
Writing Generic Functions. Lecture 20 Hartmut Kaiser hkaiser/fall_2013/csc1254.html
Writing Generic Functions Lecture 20 Hartmut Kaiser hkaiser@cct.lsu.edu http://www.cct.lsu.edu/ hkaiser/fall_2013/csc1254.html Code Quality Programming Principle of the Day Minimize Coupling - Any section
15. Pointers, Algorithms, Iterators and Containers II
498 Recall: Pointers running over the Array 499 Beispiel 15. Pointers, Algorithms, Iterators and Containers II int a[5] = 3, 4, 6, 1, 2; for (int p = a; p < a+5; ++p) std::cout
CS197c: Programming in C++
CS197c: Programming in C++ Lecture 2 Marc Cartright http://ciir.cs.umass.edu/~irmarc/cs197c/index.html Administration HW1 will be up this afternoon Written assignment Due in class next week See website
Function Templates. Consider the following function:
Function Templates Consider the following function: void swap (int& a, int& b) { int tmp = a; a = b; b = tmp; Swapping integers. This function let's you swap the contents of two integer variables. But
Agenda. The main body and cout. Fundamental data types. Declarations and definitions. Control structures
The main body and cout Agenda 1 Fundamental data types Declarations and definitions Control structures References, pass-by-value vs pass-by-references The main body and cout 2 C++ IS AN OO EXTENSION OF
Working with Batches of Data
Hartmut Kaiser hkaiser@cct.lsu.edu http://www.cct.lsu.edu/ hkaiser/fall_2012/csc1254.html 2 Abstract So far we looked at simple read a string print a string problems. Now we will look at more complex problems
QUIZ. 1. Explain the meaning of the angle brackets in the declaration of v below:
QUIZ 1. Explain the meaning of the angle brackets in the declaration of v below: This is a template, used for generic programming! QUIZ 2. Why is the vector class called a container? 3. Explain how the
Short Notes of CS201
#includes: Short Notes of CS201 The #include directive instructs the preprocessor to read and include a file into a source code file. The file name is typically enclosed with < and > if the file is a system
11. Reference Types. Swap! Reference Types: Definition. Reference Types
Swap! 11. Reference Types Reference Types: Definition and Initialization, Pass By Value, Pass by Reference, Temporary Objects, Constants, Const-References // POST: values of x and y are exchanged void
Auto - a necessary evil?
Auto - a necessary evil? Roger Orr OR/2 Limited ACCU 2013 auto is new in C++11 It has been under discussion for a while, as we shall see Some compilers added support for it early in C++0x so it has had
CS201 - Introduction to Programming Glossary By
CS201 - Introduction to Programming Glossary By #include : The #include directive instructs the preprocessor to read and include a file into a source code file. The file name is typically enclosed with
CSCI-1200 Data Structures Test 3 Practice Problem Solutions
1 Short Answer [ /21] CSCI-1200 Data Structures Test 3 Practice Problem Solutions 1.1 TreeNode Parent Pointers [ /5] In our initial version of the ds set class, the TreeNode object had 3 member variables:
Outline. 1 Function calls and parameter passing. 2 Pointers, arrays, and references. 5 Declarations, scope, and lifetimes 6 I/O
Outline EDAF30 Programming in C++ 2. Introduction. More on function calls and types. Sven Gestegård Robertz Computer Science, LTH 2018 1 Function calls and parameter passing 2 Pointers, arrays, and references
Recap: Can Specialize STL Algorithms. Recap: Can Specialize STL Algorithms. C++11 Facilities to Simplify Supporting Code
Recap: Can Specialize STL Algorithms CS 247: Software Engineering Principles C++ lambdas, bind, mem_fn void quote( string word ) { cout
THE STANDARD TEMPLATE LIBRARY (STL) Week 6 BITE 1513 Computer Game Programming
THE STANDARD TEMPLATE LIBRARY (STL) Week 6 BITE 1513 Computer Game Programming What the heck is STL???? Another hard to understand and lazy to implement stuff? Standard Template Library The standard template
Exceptions, Templates, and the STL
Exceptions, Templates, and the STL CSE100 Principles of Programming with C++, Fall 2018 (based off Chapter 16 slides by Pearson) Ryan Dougherty Arizona State University http://www.public.asu.edu/~redoughe/
Container Notes. Di erent Kinds of Containers. Types Defined by Containers. C++11 Container Notes C++11
Di erent Kinds of Containers Container Notes A container is an object that stores other objects and has methods for accessing the elements. There are two fundamentally di erent kinds of containers: Sequences
CSCI-1200 Data Structures Fall 2013 Lecture 9 Iterators & Lists
Review from Lecture 8 CSCI-1200 Data Structures Fall 2013 Lecture 9 Iterators & Lists Explored a program to maintain a class enrollment list and an associated waiting list. Unfortunately, erasing items
CS 376b Computer Vision
CS 376b Computer Vision 09 / 25 / 2014 Instructor: Michael Eckmann Today s Topics Questions? / Comments? Enhancing images / masks Cross correlation Convolution C++ Cross-correlation Cross-correlation involves
An introduction to C++ template programming
An introduction to C++ template programming Hayo Thielecke University of Birmingham http://www.cs.bham.ac.uk/~hxt March 2015 Templates and parametric polymorphism Template parameters Member functions of
CS 247: Software Engineering Principles. C++ lambdas, bind, mem_fn. U Waterloo CS247 (Spring 2017)
CS 247: Software Engineering Principles C++ lambdas, bind, mem_fn 1 Recap: Can Specialize STL Algorithms void quote( string word ) { } cout
C++ Programming Lecture 2 Software Engineering Group
C++ Programming Lecture 2 Software Engineering Group Philipp D. Schubert Contents 1. Compiler errors 2. Functions 3. std::string 4. std::vector 5. Containers 6. Pointer and reference types Compiler errors
14. Pointers, Algorithms, Iterators and Containers II
Recall: Pointers running over the Array Beispiel 14. Pointers, Algorithms, Iterators and Containers II Iterations with Pointers, Arrays: Indices vs. Pointers, Arrays and Functions, Pointers and const,
Type Aliases. Examples: using newtype = existingtype; // C++11 typedef existingtype newtype; // equivalent, still works
Type Aliases A name may be defined as a synonym for an existing type name. Traditionally, typedef is used for this purpose. In the new standard, an alias declaration can also be used C++11.Thetwoformsareequivalent.
Suppose that you want to use two libraries with a bunch of useful classes and functions, but some names collide:
COMP151 Namespaces Motivation [comp151] 1 Suppose that you want to use two libraries with a bunch of useful classes and functions, but some names collide: // File: gnutils.h class Stack {... ; class Some
A Crash Course in (Some of) Modern C++
CMPT 373 Software Development Methods A Crash Course in (Some of) Modern C++ Nick Sumner wsumner@sfu.ca With material from Bjarne Stroustrup & Herb Sutter C++ was complicated/intimidating Pointers Arithmetic
C++ 11 and the Standard Library: Containers, Iterators, Algorithms
and the Standard Library:,, Comp Sci 1575 Outline 1 2 3 4 Outline 1 2 3 4 #i n clude i n t main ( ) { i n t v a l u e 0 = 5 ; // C++ 98 i n t v a l u e 1 ( 5 ) ; // C++ 98 i n t v a
CSCI-1200 Data Structures Fall 2009 Lecture 20 Hash Tables, Part II
Review from Lecture 19 CSCI-1200 Data Structures Fall 2009 Lecture 20 Hash Tables, Part II Operators as non-member functions, as member functions, and as friend functions. A hash table is a table implementation
Qualified std::function signatures
Document number: P0045R1 Date: 2017 02 06 To: SC22/WG21 LEWG Reply to: David Krauss (david_work at me dot com) Qualified std::function signatures std::function implements type-erasure of the behavior of
G52CPP C++ Programming Lecture 18. Dr Jason Atkin
G52CPP C++ Programming Lecture 18 Dr Jason Atkin 1 Last lecture Operator Overloading Strings and streams 2 Operator overloading - what to know Know that you can change the meaning of operators Know that
MODULE 35 --THE STL-- ALGORITHM PART III
MODULE 35 --THE STL-- ALGORITHM PART III My Training Period: hours Note: Compiled using Microsoft Visual C++.Net, win32 empty console mode application. g++ compilation example is given at the end of this
Remedial C Now that we can actually use it Pete Williamson
Remedial C++ 11 Now that we can actually use it Pete Williamson (petewil00@hotmail.com) Overview (1) auto lambdas nullptr = default, = delete shared_ptr Range based for loops Overview (2) Uniform initialization
Vectors. CIS 15 : Spring 2007
Vectors CIS 15 : Spring 2007 Functionalia Midterm 2 : Ave. 58% (36.9 / 68) Med. 67% (45.5 / 68) Today: Standard Template Library Vector Template Standard Template Library C++ offers extended functionality
Outline. Variables Automatic type inference. Generic programming. Generic programming. Templates Template compilation
Outline EDAF30 Programming in C++ 4. The standard library. Algorithms and containers. Sven Gestegård Robertz Computer Science, LTH 2018 1 Type inference 2 3 The standard library Algorithms Containers Sequences
Object-Oriented Programming for Scientific Computing
Object-Oriented Programming for Scientific Computing STL and Iterators Ole Klein Interdisciplinary Center for Scientific Computing Heidelberg University ole.klein@iwr.uni-heidelberg.de Summer Semester
Introduction to C++ with content from
Introduction to C++ with content from www.cplusplus.com 2 Introduction C++ widely-used general-purpose programming language procedural and object-oriented support strong support created by Bjarne Stroustrup