Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very...
Transcript of Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very...
![Page 1: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/1.jpg)
Introduction to modern C++Olve Maudal
a 30 minute presentation for FinnOslo, Mar 18, 2015
C++ has evolved a lot since it was first introduced as "C with classes" with primitive support for object-oriented programming. In particular during the last 10-15 years the common use of the language has changed "dramatically" and the language itself has evolved accordingly. Modern C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good support for generic programming and functional programming. All of this while C++ is still a low-level language that can be used to create programs that compete with programs written in assembler both in terms of speed and size.
We start with a brief history of C++ before focusing on new features in C++11/14 and a demonstration of some typical modern programming techniques.
![Page 2: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/2.jpg)
• Brief History of C and C++•New features in C++11/14•Generic Programming•The future of C++
![Page 3: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/3.jpg)
Brief History of C and C++
![Page 4: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/4.jpg)
http://www.aftenposten.no/fakta/innsikt/Da-skiene-ble-vinger-7459947.html
![Page 5: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/5.jpg)
40'sMachine code, symbol tables and Assembler
![Page 6: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/6.jpg)
50'sFortran, Lisp, Cobol, Algol
![Page 7: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/7.jpg)
60'smany, many languages appeared in this period. In particular...
CPL
![Page 8: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/8.jpg)
60's... and Simula
![Page 9: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/9.jpg)
Both CPL and Simula were examples of very elegant languages...
![Page 10: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/10.jpg)
... but there was also a need for brutally efficient languages
![Page 11: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/11.jpg)
70'sBCPL, B, C
... but there was also a need for brutally efficient languages
![Page 12: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/12.jpg)
80'sC with classes, C++/CFront, ARM
Bjarne Stroustrup combined the efficiency of C with some of the elegance from Simula...
![Page 13: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/13.jpg)
90'sX3J16, C++arm, WG21, C++98, STL
C++ was improved and became standardized
![Page 14: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/14.jpg)
C++
=
BCPL
+
Simula
+
![Page 15: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/15.jpg)
Ouch... Template Metaprogramming
![Page 16: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/16.jpg)
C++03, TR1, Boost and other external libraries
While the language itself saw some minor improvements after C++98, Boost and other external libraries acted like laboratories for experimenting with potential new C++ features. Resulting in...
![Page 17: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/17.jpg)
C++11/C++14
With the latest version C++ feels like a new language
![Page 18: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/18.jpg)
The future of C++?
![Page 19: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/19.jpg)
Modern C++ by Example
unless specified otherwise, all these code snippets should compile cleanly with a modern C++ compiler
![Page 20: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/20.jpg)
#include <iostream> #include <vector>
static void transmit_item(int i) { std::cout << i << std::endl; // ... } static void transmit_log(const std::vector<int> & log) { for (std::vector<int>::const_iterator it = log.cbegin(); it != log.cend(); ++it) transmit_item(*it); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(log); }
![Page 21: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/21.jpg)
#include <iostream> #include <vector>
static void transmit_item(int i) { std::cout << i << std::endl; // ... } static void transmit_log(const std::vector<int> & log) { for (std::vector<int>::const_iterator it = log.cbegin(); it != log.cend(); ++it) transmit_item(*it); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(log); }
$ g++-4.9 -std=c++1y -Wall -Wextra -pedantic -Werror foo.cpp && ./a.out 20 24 37 42 23 45 37 $
![Page 22: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/22.jpg)
#include <iostream> #include <vector>
static void transmit_item(int i) { std::cout << i << std::endl; // ... } static void transmit_log(const std::vector<int> & log) { for (std::vector<int>::const_iterator it = log.cbegin(); it != log.cend(); ++it) transmit_item(*it); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(log); }
![Page 23: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/23.jpg)
#include <iostream> #include <vector>
static void transmit_item(int i) { std::cout << i << std::endl; // ... } static void transmit_log(const std::vector<int> & log) { for (decltype(log.cbegin()) it = log.cbegin(); it != log.cend(); ++it) transmit_item(*it); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(log); }
![Page 24: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/24.jpg)
#include <iostream> #include <vector>
static void transmit_item(int i) { std::cout << i << std::endl; // ... } static void transmit_log(const std::vector<int> & log) { for (auto it = log.cbegin(); it != log.cend(); ++it) transmit_item(*it); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(log); }
![Page 25: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/25.jpg)
#include <iostream> #include <vector>
static void transmit_item(int i) { std::cout << i << std::endl; // ... } static void transmit_log(const std::vector<int> & log) { for (auto it = log.cbegin(); it != log.cend(); ++it) transmit_item(*it); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(log); }
![Page 26: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/26.jpg)
#include <iostream> #include <vector>
static void transmit_item(int i) { std::cout << i << std::endl; // ... } static void transmit_log(const std::vector<int> & log) { for (auto it = log.cbegin(); it != log.cend(); ++it)
transmit_item(*it); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(log); }
![Page 27: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/27.jpg)
#include <iostream> #include <vector>
static void transmit_item(int i) { std::cout << i << std::endl; // ... } static void transmit_log(const std::vector<int> & log) { for (auto it = log.cbegin(); it != log.cend(); ++it) transmit_item(*it); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(log); }
![Page 28: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/28.jpg)
#include <iostream> #include <vector>
static void transmit_item(int i) { std::cout << i << std::endl; // ... } static void transmit_log(const std::vector<int> & log) { for (auto i : log) transmit_item(i); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(log); }
![Page 29: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/29.jpg)
#include <iostream> #include <vector>
static void transmit_item(int i) { std::cout << i << std::endl; // ... } static void transmit_log(const std::vector<int> & log) { for (auto i : log) transmit_item(i); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(log); }
![Page 30: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/30.jpg)
#include <iostream> #include <vector> #include <algorithm>
static void transmit_item(int i) { std::cout << i << std::endl; // ... } static void transmit_log(const std::vector<int> & log) { std::for_each(std::begin(log), std::end(log), transmit_item);
}
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(log); }
![Page 31: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/31.jpg)
#include <iostream> #include <vector> #include <algorithm>
static void transmit_item(int i) { std::cout << i << std::endl; // ... } static void transmit_log(const std::vector<int> & log) {
std::for_each(std::begin(log), std::end(log), transmit_item); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(log); }
![Page 32: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/32.jpg)
#include <iostream> #include <vector> #include <algorithm>
static void transmit_item(int i) { std::cout << i << std::endl; // ... } static void transmit_log(const std::vector<int> & log) { std::sort(std::begin(log), std::end(log)); std::for_each(std::begin(log), std::end(log), transmit_item); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(log); }
![Page 33: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/33.jpg)
#include <iostream> #include <vector> #include <algorithm>
static void transmit_item(int i) { std::cout << i << std::endl; // ... } static void transmit_log(std::vector<int> log) { std::sort(std::begin(log), std::end(log)); std::for_each(std::begin(log), std::end(log), transmit_item); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(log); }
![Page 34: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/34.jpg)
#include <iostream> #include <vector> #include <algorithm>
static void transmit_item(int i) { std::cout << i << std::endl; // ... } static void transmit_log(std::vector<int> & log) { std::sort(std::begin(log), std::end(log)); std::for_each(std::begin(log), std::end(log), transmit_item); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(log); }
![Page 35: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/35.jpg)
#include <iostream> #include <vector> #include <algorithm>
static void transmit_item(int i) { std::cout << i << std::endl; // ... } static void transmit_log(std::vector<int> && log) { std::sort(std::begin(log), std::end(log)); std::for_each(std::begin(log), std::end(log), transmit_item); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(std::move(log)); }
![Page 36: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/36.jpg)
#include <iostream> #include <vector> #include <algorithm>
static void transmit_item(int i) { std::cout << i << std::endl; // ... }
static void transmit_log(std::vector<int> && log) { std::sort(std::begin(log), std::end(log)); std::for_each(std::begin(log), std::end(log), transmit_item); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(std::move(log)); }
![Page 37: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/37.jpg)
#include <iostream> #include <vector> #include <algorithm>
static void transmit_item(int i) { std::cout << i << std::endl; // ... }
static bool mycomp(int lhs, int rhs) { return lhs > rhs; }
static void transmit_log(std::vector<int> && log) { std::sort(std::begin(log), std::end(log), mycomp); std::for_each(std::begin(log), std::end(log), transmit_item); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(std::move(log)); }
![Page 38: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/38.jpg)
#include <iostream> #include <vector> #include <algorithm>
static void transmit_item(int i) { std::cout << i << std::endl; // ... }
static bool mycomp(int lhs, int rhs) { return lhs > rhs; }
static void transmit_log(std::vector<int> && log, bool comp(int, int)) { std::sort(std::begin(log), std::end(log), comp); std::for_each(std::begin(log), std::end(log), transmit_item); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(std::move(log), mycomp); }
![Page 39: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/39.jpg)
#include <iostream> #include <vector> #include <algorithm>
static void transmit_item(int i) { std::cout << i << std::endl; // ... }
static bool mycomp(int lhs, int rhs) { return lhs > rhs; }
static void transmit_log(std::vector<int> && log) { std::sort(std::begin(log), std::end(log)); std::for_each(std::begin(log), std::end(log), transmit_item); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(std::move(log)); }
![Page 40: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/40.jpg)
#include <iostream> #include <vector> #include <algorithm>
static void transmit_item(int i) { std::cout << i << std::endl; // ... }
static void transmit_log(std::vector<int> && log) { std::sort(std::begin(log), std::end(log)); std::for_each(std::begin(log), std::end(log), transmit_item); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(std::move(log)); }
![Page 41: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/41.jpg)
#include <iostream> #include <vector> #include <algorithm>
static void transmit_item(int i) { std::cout << i << std::endl; // ... }
static void transmit_log(std::vector<int> && log) { std::sort(std::begin(log), std::end(log)); std::for_each(std::begin(log), std::end(log), transmit_item); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(std::move(log)); }
![Page 42: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/42.jpg)
#include <iostream> #include <vector> #include <algorithm>
static void transmit_item(int i) { std::cout << i << std::endl; // ... }
static void transmit_log(std::vector<int> && log) {
std::sort(std::begin(log), std::end(log)); std::for_each(std::begin(log), std::end(log), transmit_item); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(std::move(log)); }
![Page 43: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/43.jpg)
#include <iostream> #include <vector> #include <algorithm> #include <functional>
static void transmit_item(int i) { std::cout << i << std::endl; // ... }
static void transmit_log(std::vector<int> && log, int limit) { std::function<bool (int)> myfilter = [limit](int i) { return i <= limit; }; log.erase(std::remove_if(std::begin(log), std::end(log), myfilter), std::end(log)); std::sort(std::begin(log), std::end(log)); std::for_each(std::begin(log), std::end(log), transmit_item); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(std::move(log), 23); }
![Page 44: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/44.jpg)
#include <iostream> #include <vector> #include <algorithm> #include <functional>
static void transmit_item(int i) { std::cout << i << std::endl; // ... }
static void transmit_log(std::vector<int> && log, std::function<bool (int)> myfilter) {
log.erase(std::remove_if(std::begin(log), std::end(log), myfilter), std::end(log)); std::sort(std::begin(log), std::end(log)); std::for_each(std::begin(log), std::end(log), transmit_item); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(std::move(log), [](int i) { return i <= 23; }); }
![Page 45: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/45.jpg)
#include <iostream> #include <vector> #include <algorithm> #include <functional>
static void transmit_item(int i) { std::cout << i << std::endl; // ... }
static void transmit_log(std::vector<int> && log, std::function<bool (int)> myfilter) { log.erase(std::remove_if(std::begin(log), std::end(log), myfilter), std::end(log)); std::sort(std::begin(log), std::end(log)); std::for_each(std::begin(log), std::end(log), transmit_item); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(std::move(log), [](int i) { return i <= 23; }); }
![Page 46: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/46.jpg)
#include <iostream> #include <vector> #include <algorithm> #include <functional>
static void transmit_item(int i) { std::cout << i << std::endl; // ... }
template <typename Filt> static void transmit_log(std::vector<int> && log, Filt myfilter) { log.erase(std::remove_if(std::begin(log), std::end(log), myfilter), std::end(log)); std::sort(std::begin(log), std::end(log)); std::for_each(std::begin(log), std::end(log), transmit_item); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(std::move(log), [](int i) { return i <= 23; }); }
![Page 47: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/47.jpg)
#include <iostream> #include <vector> #include <algorithm> #include <functional>
static void transmit_item(int i) { std::cout << i << std::endl; // ... }
template <typename Log, typename Filt> static void transmit_log(Log && log, Filt myfilter) { log.erase(std::remove_if(std::begin(log), std::end(log), myfilter), std::end(log)); std::sort(std::begin(log), std::end(log)); std::for_each(std::begin(log), std::end(log), transmit_item); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(std::move(log), [](int i) { return i <= 23; }); }
![Page 48: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/48.jpg)
#include <iostream> #include <vector> #include <algorithm> #include <functional>
static void transmit_item(int i) { std::cout << i << std::endl; // ... }
template <typename Log, typename Filt> static void transmit_log(Log && log, Filt myfilter) { log.erase(std::remove_if(std::begin(log), std::end(log), myfilter), std::end(log)); std::sort(std::begin(log), std::end(log)); std::for_each(std::begin(log), std::end(log), transmit_item); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(std::move(log), [](int i) { return i <= 23; }); }
![Page 49: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/49.jpg)
#include <iostream> #include <vector> #include <algorithm> #include <functional>
template <typename T> static void transmit_item(T i) { std::cout << i << std::endl; // ... }
template <typename Log, typename Filt> static void transmit_log(Log && log, Filt myfilter) { log.erase(std::remove_if(std::begin(log), std::end(log), myfilter), std::end(log)); std::sort(std::begin(log), std::end(log)); std::for_each(std::begin(log), std::end(log), transmit_item<int>); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(std::move(log), [](int i) { return i <= 23; }); }
![Page 50: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/50.jpg)
#include <iostream> #include <vector> #include <algorithm> #include <functional>
template <typename T> static void transmit_item(T i) { std::cout << i << std::endl; // ... }
template <typename Log, typename Filt> static void transmit_log(Log && log, Filt myfilter) { log.erase(std::remove_if(std::begin(log), std::end(log), myfilter), std::end(log)); std::sort(std::begin(log), std::end(log)); std::for_each(std::begin(log), std::end(log), transmit_item<int>); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(std::move(log), [](int i) { return i <= 23; }); }
![Page 51: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/51.jpg)
#include <iostream> #include <vector> #include <algorithm> #include <functional>
template <typename T> static void transmit_item(T i) { std::cout << i << std::endl; // ... }
template <typename Log, typename Filt> static void transmit_log(Log && log, Filt myfilter) { log.erase(std::remove_if(std::begin(log), std::end(log), myfilter), std::end(log)); std::sort(std::begin(log), std::end(log)); std::for_each(std::begin(log), std::end(log), transmit_item<typename Log::value_type>); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(std::move(log), [](int i) { return i <= 23; }); }
![Page 52: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/52.jpg)
#include <iostream> #include <vector> #include <algorithm> #include <functional>
template <typename T> static void transmit_item(T i) { std::cout << i << std::endl; // ... }
template <typename Log, typename Filt> static void transmit_log(Log && log, Filt myfilter) { log.erase(std::remove_if(std::begin(log), std::end(log), myfilter), std::end(log)); std::sort(std::begin(log), std::end(log)); std::for_each(std::begin(log), std::end(log), transmit_item<typename Log::value_type>); }
int main() {
std::vector<int> log{20,24,37,42,23,45,37}; transmit_log(std::move(log), [](int i) { return i <= 23; }); }
![Page 53: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/53.jpg)
#include <iostream> #include <vector> #include <algorithm> #include <functional>
template <typename T> static void transmit_item(T i) { std::cout << i << std::endl; // ... }
template <typename Log, typename Filt> static void transmit_log(Log && log, Filt myfilter) { log.erase(std::remove_if(std::begin(log), std::end(log), myfilter), std::end(log)); std::sort(std::begin(log), std::end(log)); std::for_each(std::begin(log), std::end(log), transmit_item<typename Log::value_type>); }
int main() { using log_item_type = long; std::vector<log_item_type> log{20,24,37,42,23,45,37}; transmit_log(std::move(log), [](log_item_type i) { return i <= 23; }); }
![Page 54: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/54.jpg)
#include <iostream> #include <deque> #include <algorithm> #include <functional>
template <typename T> static void transmit_item(T i) { std::cout << i << std::endl; // ... }
template <typename Log, typename Filt> static void transmit_log(Log && log, Filt myfilter) { log.erase(std::remove_if(std::begin(log), std::end(log), myfilter), std::end(log)); std::sort(std::begin(log), std::end(log)); std::for_each(std::begin(log), std::end(log), transmit_item<typename Log::value_type>); }
int main() { using log_item_type = long; std::deque<log_item_type> log{20,24,37,42,23,45,37}; transmit_log(std::move(log), [](log_item_type i) { return i <= 23; }); }
![Page 55: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/55.jpg)
#include <iostream> #include <vector> #include <algorithm> #include <functional>
template <typename T> static void transmit_item(T i) { std::cout << i << std::endl; // ... }
template <typename Log, typename Filt> static void transmit_log(Log && log, Filt myfilter) { log.erase(std::remove_if(std::begin(log), std::end(log), myfilter), std::end(log)); std::sort(std::begin(log), std::end(log)); std::for_each(std::begin(log), std::end(log), transmit_item<typename Log::value_type>); }
int main() { using log_item_type = long; std::vector<log_item_type> log{20,24,37,42,23,45,37}; transmit_log(std::move(log), [](log_item_type i) { return i <= 23; }); }
![Page 56: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/56.jpg)
#include <iostream> #include <vector> #include <algorithm> #include <functional>
template <typename T> static void transmit_item(T i) {
std::cout << i << std::endl; // ... }
template <typename Log, typename Filt> static void transmit_log(Log && log, Filt myfilter) { log.erase(std::remove_if(std::begin(log), std::end(log), myfilter), std::end(log)); std::sort(std::begin(log), std::end(log)); std::for_each(std::begin(log), std::end(log), transmit_item<typename Log::value_type>); }
int main() { using log_item_type = long; std::vector<log_item_type> log{20,24,37,42,23,45,37}; transmit_log(std::move(log), [](log_item_type i) { return i <= 23; }); }
![Page 57: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/57.jpg)
#include <iostream> #include <vector> #include <algorithm> #include <functional> #include <type_traits>
template <typename T> static void transmit_item(T i) { static_assert(std::is_integral<T>::value, "integral type expected"); std::cout << i << std::endl; // ... }
template <typename Log, typename Filt> static void transmit_log(Log && log, Filt myfilter) { log.erase(std::remove_if(std::begin(log), std::end(log), myfilter), std::end(log)); std::sort(std::begin(log), std::end(log)); std::for_each(std::begin(log), std::end(log), transmit_item<typename Log::value_type>); }
int main() { using log_item_type = long; std::vector<log_item_type> log{20,24,37,42,23,45,37}; transmit_log(std::move(log), [](log_item_type i) { return i <= 23; }); }
![Page 58: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/58.jpg)
#include <iostream> #include <vector> #include <algorithm> #include <functional> #include <type_traits>
template <typename T> static void transmit_item(T i) { static_assert(std::is_integral<T>::value, "integral type expected"); std::cout << i << std::endl; // ... }
template <typename Log, typename Filt> static void transmit_log(Log && log, Filt myfilter) { log.erase(std::remove_if(std::begin(log), std::end(log), myfilter), std::end(log)); std::sort(std::begin(log), std::end(log)); std::for_each(std::begin(log), std::end(log), transmit_item<typename Log::value_type>); }
int main() { using log_item_type = long; std::vector<log_item_type> log{20,24,37,42,23,45,37}; transmit_log(std::move(log), [](log_item_type i) { return i <= 23; }); }
![Page 59: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/59.jpg)
#include <iostream> #include <vector> #include <algorithm> #include <functional> #include <type_traits> #include "mystuff"
template <typename T> static void transmit_item(T i) { static_assert(my::is_transmittable<T>::value, "transmittable type expected"); std::cout << i << std::endl; // ... }
template <typename Log, typename Filt> static void transmit_log(Log && log, Filt myfilter) { log.erase(std::remove_if(std::begin(log), std::end(log), myfilter), std::end(log)); std::sort(std::begin(log), std::end(log)); std::for_each(std::begin(log), std::end(log), transmit_item<typename Log::value_type>); }
int main() { using log_item_type = long; std::vector<log_item_type> log{20,24,37,42,23,45,37}; transmit_log(std::move(log), [](log_item_type i) { return i <= 23; }); }
![Page 60: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/60.jpg)
#include <iostream> #include <vector> #include <algorithm> #include <functional> #include <type_traits> #include "mystuff"
template <typename T> require Transmittable<T> static void transmit_item(T i) {
std::cout << i << std::endl; // ... }
template <typename Log, typename Filt> static void transmit_log(Log && log, Filt myfilter) { log.erase(std::remove_if(std::begin(log), std::end(log), myfilter), std::end(log)); std::sort(std::begin(log), std::end(log)); std::for_each(std::begin(log), std::end(log), transmit_item<typename Log::value_type>); }
int main() { using log_item_type = long; std::vector<log_item_type> log{20,24,37,42,23,45,37}; transmit_log(std::move(log), [](log_item_type i) { return i <= 23; }); }
![Page 61: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/61.jpg)
#include <iostream> #include <vector> #include <algorithm> #include <functional> #include <type_traits> #include "mystuff"
template <Transmittable T> static void transmit_item(T i) {
std::cout << i << std::endl; // ... }
template <typename Log, typename Filt> static void transmit_log(Log && log, Filt myfilter) { log.erase(std::remove_if(std::begin(log), std::end(log), myfilter), std::end(log)); std::sort(std::begin(log), std::end(log)); std::for_each(std::begin(log), std::end(log), transmit_item<typename Log::value_type>); }
int main() { using log_item_type = long; std::vector<log_item_type> log{20,24,37,42,23,45,37}; transmit_log(std::move(log), [](log_item_type i) { return i <= 23; }); }
![Page 62: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/62.jpg)
#include <iostream> #include <vector> #include <algorithm> #include <functional> #include <type_traits> #include "mystuff"
template <Transmittable T> static void transmit_item(T i) {
std::cout << i << std::endl; // ... }
template <Iterable Log, UnaryFunctionPredicate Filt> static void transmit_log(Log && log, Filt myfilter) { log.erase(std::remove_if(std::begin(log), std::end(log), myfilter), std::end(log)); std::sort(std::begin(log), std::end(log)); std::for_each(std::begin(log), std::end(log), transmit_item<typename Log::value_type>); }
int main() { using log_item_type = long; std::vector<log_item_type> log{20,24,37,42,23,45,37}; transmit_log(std::move(log), [](log_item_type i) { return i <= 23; }); }
![Page 63: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/63.jpg)
#include <iostream> #include <vector> #include <algorithm>
static void transmit_item(int i) { std::cout << i << std::endl; // ... }
static size_t transmit_log(const std::vector<int> & log) { std::for_each(std::begin(log), std::end(log), transmit_item); return log.size(); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; size_t items = transmit_log(log); std::cout << "# " << items << std::endl; }
![Page 64: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/64.jpg)
#include <iostream> #include <vector> #include <algorithm>
static void transmit_item(int i) { std::cout << i << std::endl;
// ... }
static size_t transmit_log(const std::vector<int> & log) { std::for_each(std::begin(log), std::end(log), transmit_item); return log.size(); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; size_t items = transmit_log(log); std::cout << "# " << items << std::endl; }
![Page 65: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/65.jpg)
#include <iostream> #include <vector> #include <algorithm> #include <chrono> #include <thread>
static void transmit_item(int i) { std::cout << i << std::endl; std::this_thread::sleep_for(std::chrono::milliseconds(200)); // ... }
static size_t transmit_log(const std::vector<int> & log) { std::for_each(std::begin(log), std::end(log), transmit_item); return log.size(); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; size_t items = transmit_log(log); std::cout << "# " << items << std::endl; }
![Page 66: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/66.jpg)
#include <iostream> #include <vector> #include <algorithm> #include <chrono> #include <thread>
static void transmit_item(int i) { std::cout << i << std::endl; std::this_thread::sleep_for(std::chrono::milliseconds(200)); // ... }
static size_t transmit_log(const std::vector<int> & log) { std::for_each(std::begin(log), std::end(log), transmit_item); return log.size(); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; size_t items = transmit_log(log);
std::cout << "# " << items << std::endl; }
![Page 67: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/67.jpg)
#include <iostream> #include <vector> #include <algorithm> #include <chrono> #include <thread> #include <future>
static void transmit_item(int i) { std::cout << i << std::endl; std::this_thread::sleep_for(std::chrono::milliseconds(200)); // ... }
static size_t transmit_log(const std::vector<int> & log) { std::for_each(std::begin(log), std::end(log), transmit_item); return log.size(); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; auto res = std::async(std::launch::async, transmit_log, log); size_t items = res.get(); std::cout << "# " << items << std::endl; }
![Page 68: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/68.jpg)
#include <iostream> #include <vector> #include <algorithm> #include <chrono> #include <thread> #include <future>
static void transmit_item(int i) { std::cout << i << std::endl; std::this_thread::sleep_for(std::chrono::milliseconds(200)); // ... }
static size_t transmit_log(const std::vector<int> & log) { std::for_each(std::begin(log), std::end(log), transmit_item); return log.size(); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; auto res = std::async(std::launch::async, transmit_log, log); size_t items = res.get(); std::cout << "# " << items << std::endl; }
$ g++-4.9 -std=c++1y -Wall -Wextra -pedantic -Werror -pthread foo.cpp
![Page 69: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/69.jpg)
#include <iostream> #include <vector> #include <algorithm> #include <chrono> #include <thread> #include <future>
static void transmit_item(int i) { std::cout << i << std::endl; std::this_thread::sleep_for(std::chrono::milliseconds(200)); // ... }
static size_t transmit_log(const std::vector<int> & log) { std::for_each(std::begin(log), std::end(log), transmit_item); return log.size(); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; auto res = std::async(std::launch::async, transmit_log, log); size_t items = res.get(); std::cout << "# " << items << std::endl; }
![Page 70: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/70.jpg)
#include <iostream> #include <vector> #include <algorithm> #include <chrono> #include <thread> #include <future>
static void transmit_item(int i) { std::cout << i << std::endl; std::this_thread::sleep_for(std::chrono::milliseconds(200)); // ... }
static size_t transmit_log(const std::vector<int> & log) { std::for_each(std::begin(log), std::end(log), transmit_item); return log.size(); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; auto res = std::async(std::launch::async, transmit_log, log);
size_t items = res.get(); std::cout << "# " << items << std::endl; }
![Page 71: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/71.jpg)
#include <iostream> #include <vector> #include <algorithm> #include <chrono> #include <thread> #include <future>
static void transmit_item(int i) { std::cout << i << std::endl; std::this_thread::sleep_for(std::chrono::milliseconds(200)); // ... }
static size_t transmit_log(const std::vector<int> & log) { std::for_each(std::begin(log), std::end(log), transmit_item); return log.size(); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; auto res = std::async(std::launch::async, transmit_log, log); for (int i=0; i<5; i++) { std::this_thread::sleep_for(std::chrono::milliseconds(77)); std::cout << "do something else..." << std::endl; } size_t items = res.get(); std::cout << "# " << items << std::endl; }
![Page 72: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/72.jpg)
#include <iostream> #include <vector> #include <algorithm> #include <chrono> #include <thread> #include <future>
static void transmit_item(int i) { std::cout << i << std::endl; std::this_thread::sleep_for(std::chrono::milliseconds(200)); // ... }
static size_t transmit_log(const std::vector<int> & log) { std::for_each(std::begin(log), std::end(log), transmit_item); return log.size(); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; auto res = std::async(std::launch::async, transmit_log, log); for (int i=0; i<5; i++) { std::this_thread::sleep_for(std::chrono::milliseconds(123)); std::cout << "do something else..." << std::endl; } size_t items = res.get(); std::cout << "# " << items << std::endl; }
![Page 73: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/73.jpg)
#include <iostream> #include <vector> #include <algorithm> #include <chrono> #include <thread> #include <future>
static void transmit_item(int i) { std::cout << i << std::endl; std::this_thread::sleep_for(std::chrono::milliseconds(200)); // ... }
static size_t transmit_log(const std::vector<int> & log) { std::for_each(std::begin(log), std::end(log), transmit_item); return log.size(); }
int main() { std::vector<int> log{20,24,37,42,23,45,37}; auto res = std::async(std::launch::async, transmit_log, log); for (int i=0; i<5; i++) { std::this_thread::sleep_for(std::chrono::milliseconds(123)); std::cout << "do something else..." << std::endl; } size_t items = res.get(); std::cout << "# " << items << std::endl; }
20 do something else... 24 do something else... do something else... 37 do something else... 42 do something else... 23 45 37 # 7
![Page 74: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/74.jpg)
Modern C++- move semantics (rvalue references, value semantics)- type deduction (decltype, auto)- better support for OOP (attributes, member initialization, delegation) - compile time computation (templates, static_assert, constexpr)- template metaprogramming (traits, constraints, concepts)- robust resource management (RAII, unique, shared)- high-order parallelism (atomic, mutex, async, promises and futures)- functional programming (algorithms, lamdas, closures, lazy evaluation)- misc (chrono, user-defined literals, regex, uniform initialization)
![Page 75: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/75.jpg)
The success of C++ can also be meassured in that it has inspired a lot of other programming languages. Java, C#, Scala, D, Go, Swift just to mention a few
![Page 76: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/76.jpg)
The success of C++ can also be meassured in that it has inspired a lot of other programming languages. Java, C#, Scala, D, Go, Swift just to mention a few
![Page 77: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/77.jpg)
The success of C++ can also be meassured in that it has inspired a lot of other programming languages. Java, C#, Scala, D, Go, Swift just to mention a few
Eddie "The Eagle" Edwards (1988)
![Page 78: Introduction to modern C++ - pvv.orgoma/ModernCPP_Finn_Mar2015.pdf · C++ (C++11/14) is still very suitable for object-oriented programming, but now the language also provides good](https://reader033.fdocuments.net/reader033/viewer/2022042803/5f4f8758b38a8464cd6bb6ca/html5/thumbnails/78.jpg)
!