Modern C++ (less == more) (more == more)!

Transcription

1

2 Modern C++ (less == more) (more == more)

3 History 1983AT&TC++/Cfront(Bjarne(Stroustrup) 1981Objec:ve<C(Brad(Cox(and(Tom(Love) 1969C(Dennis(Ritchie) 1979CwithClasses(Bjarne(Stroustrup) 1968ALGOL ALGOL58(Bauer,(Backus(et(al) 1978K&RC(Brian(Kernighan(and(Dennis(Ritchie) 1989ANSI/ISOC FORTRAN FORTRAN(John(Backus) 1977FORTRAN GNUCReleased 1999ISOC ISOC ISOC ISOC ClangReleased 2008ISOC++TR1 2014ISOC ISOC

4 What is C++? A general purpose programming language Has a strong bias towards systems programming One layer above assembly language Multi-paradigm language Imperative (C99 superset) int do_rdrand() int r; asm("retry: rdrand eax\n " jnc retry;\n" : "=a" (r)); return r; Object-oriented (polymorphism, inheritance) Functional (immutability, lambdas, currying) Meta-programming (templates, algorithms)

5 Why C++ ISO/IEC 14882:2011 International standards organisation represented by national bodies from 164 member countries Not open to manipulation by individuals or corporations for proprietary control COBOL, Fortran, Ada, Prolog, C, C++, Forth, ECMAscript C++ is a software engineering language that enables the production of high performance type-safe, statically verifiable native software.

6 Why C++ C++ is popular Source:

7 C++ projects GNU Compiler Collection, LLVM, Clang Java Virtual Machine, Dart, V8, Facebook HHVM Webkit, Chrome, Safari, Firefox, Internet Explorer MySQL, LevelDB, MongoDB, SAP DB Adobe, Autodesk, Apple, Microsoft, Scientific computing, Computer Aided Engineering, Operations Research, Telecommunications, Bitcoin

8 What is Modern C++? Modern C++ feels like a new language (Bjarne Stroustrup) C++11 refines the C++ language in a backwards compatible way to support existing C++ code while enabling simpler and more modern idioms Pass-by-value everywhere STL containers got smarter with r-value references Lambdas, initializer lists, variadic templates, etc Improved memory management Improved standard library

9 Less is exponentially more I was asked a few weeks ago, "What was the biggest surprise you encountered rolling out Go?" I knew the answer instantly: Although we expected C++ programmers to see Go as an alternative, instead most Go programmers come from languages like Python and Ruby. Very few come from C++. We Ken, Robert and myself were C++ programmers when we designed a new language to solve the problems that we thought needed to be solved for the kind of software we wrote. It seems almost paradoxical that other C++ programmers don't seem to care. Rob Pike

10 C++11 has got more std::future <atomic> static_assert auto <type_traits> <functional> lambda std::shared_ptr <thread> constexpr <regex> std::async <mutex> <random> decltype std::unique_ptr <chrono> std::tuple <memory> std::unordered_map nullptr std::unordered_set

11 C++11 has got less C++98 #include <iostream> #include <vector> using namespace std; int main() vector<int> v; C++11 #include <iostream> #include <vector> using namespace std; int main() vector<int> v = 2,3,5,7; v.push_back(2); v.push_back(3); v.push_back(5); v.push_back(7); vector<int>::iterator i; for (i = v.begin(); i = v.end(); i++) cout << *i << endl; for (auto a : v) cout << a << endl; or even less int main() for (auto a : 2,3,5,7) cout << a << endl;

12 Template Metaprogramming The C++ template system is turing complete at compile time #include <iostream> // using namespace std; template <int N> struct Factorial enum value = N * Factorial<N - 1>::value ; ; template <> struct Factorial<0> enum value = 1 ; ; int main() cout << Factorial<4>::value << endl; cout << Factorial<0>::value << endl;

13 Zero-copy layout OO Language class Price int timestamp; int volume; double price; C++11 struct Price int timestamp; int volume; double price; Price(int timestamp, int volume, double price) this.timestamp = timestamp; this.volume = volume; this.price = price; static void main(string args[]) ArrayList<Price> prices; prices.ensurecapacity(4); prices.add(new Price( , 5, 26.05)); prices.add(new Price( , 40, 26.15)); prices.add(new Price( , 100, )); prices.add(new Price( , 112, 26.15)); Price(int timestamp, int volume, double price) : timestamp(timestamp), volume(volume), price(price) ; int main() vector<price> prices; prices.reserve(4); prices.emplace_back( , 5, 26.05); prices.emplace_back( , 40, 26.15); prices.emplace_back( , 100, ); prices.emplace_back( , 112, 26.15); Containers use polymorphism and type erase Need to devolve to structure of primitive arrays to get reasonable performance, but SoA has bad cache behaviour Looks are deceiving Templates instantiate optimized code for the type Superset - allows implementation of polymorphic containers i.e. vector<object>

14 Zero-copy layout OO Language bytes, 5 allocations Opaque Object Header (16-bytes) array object reference size Opaque Object Header (16-bytes) length 64-bit Object Reference (8-bytes) 64-bit Object Reference (8-bytes) 64-bit Object Reference (8-bytes) Opaque Object Header (16-bytes) Opaque Object Header (16-bytes) Opaque Object Header (16-bytes) C bytes, 2 allocations array ptr size capacity

15 No more leaks std::unique_ptr Singleton pointer wrapper Ensures a single copy of an object No performance overhead Automatic release (no more delete) std::shared_ptr Reference counting pointer wrapper Thread-safe reference counter Acts like a normal pointer but has overhead Use when correctness is more important than performance Automatic release (no more delete)

16 R-value references template<typename T> void foo(t&&) New signature to detect r-values (temporaries) In a nut shell enables compile time detection of r-value temporaries (versus l-values) to implement efficient zero-copy move semantics and perfect forwarding What is an r-value? Adds complexity to hide complexity Feature designed for STL and library writers std::forward, std::move Efficient pass by value and return by value for containers Simplifies idiom of user code vector<price> raise(vector<price> prices) /* does something */ raise(price( , 5, 26.05), Price( , 40, 26.15));

17 Initializer lists Array initialization was a C++98 bugbear Adds new initializer syntax foo1,2,3,4 struct myclass myclass (int,int); myclass (initializer_list<int>); /* definitions... */ ; myclass foo 10,20; // calls initializer_list ctor myclass bar (10,20); // calls first constructor Can be used in constructor member initialization New header <initializer_list> New template initializer_list<t> template <typename T> struct vec vec(t x) : mx, 0, 0, 1 vec(t x, T y) : mx, y, 0, 1 vec(t x, T y, T z) : mx, y, z, 1 vec(t x, T y, T z, T w) : mx, y, z, w T m[4]; ; vec<float> a(1, 2, 3);

18 Delegating constructors Really. C++98 didn t have them template <typename T> struct vec vec(t x) : vec(x, 0, 0, 1) vec(t x, T y) : vec(x, y, 0, 1) vec(t x, T y, T z) : vec(x, y, z, 1) vec(t x, T y, T z, T w) : mx, y, z, w ; T m[4];

19 Threads and Futures std::thread std::async std::future C++ is in now line with other modern languages thread capabilities #include <iostream> #include <vector> #include <algorithm> #include <numeric> #include <future> // source template <typename I> int parallel_sum(i beg, I end) typename I::difference_type len = end - beg; if (len < 1000) return std::accumulate(beg, end, 0); I mid = beg + len/2; auto handle = std::async(std::launch::async, parallel_sum<i>, mid, end); int sum = parallel_sum(beg, mid); return sum + handle.get(); int main() std::vector<int> v(10000, 1); std::cout << "The sum is " << parallel_sum(v.begin(), v.end()) << \n';

20 Compile-time type identification New header <type_traits> std::is_void<t> std::is_integral<t> std::is_array<t> std::is_class<t> std::is_pointer<t> std::is_volatile<t> template <typename R> static const EGType& typeof() typedef typename std::remove_extent<r>::type A; typedef typename std::remove_pointer<r>::type P; if (std::is_array<r>::value) typedef typename std::remove_const<a>::type V; return arraytype<v>(); else if (std::is_pointer<r>::value) typedef typename std::remove_const<p>::type V; return pointertype<v>(); else typedef typename std::remove_const<r>::type V; return integraltype<v>(); std::rank<t>, std::extent<t,n>. many many more.

21 Variadic templates Variadic templates allow implementation of a compile time type safe printf( ) Variadic templates combined with compile time type identification gives super powers to C++ Can collect type information at compile time and use at runtime Allows creation of an Objective-C style messaging system with late-binding #include <type_traits> #include <functional> #include <string> #include <iostream> #include <iomanip> using namespace std; using namespace std::placeholders; template<typename T> void reflect_compiler_reflect(t value) cout << setw(70) << typeid(t).name() << " is_pointer=" << is_pointer<t>::value << " is_integral=" << is_integral<t>::value << " is_floating_point=" << is_floating_point<t>::value << " is_class=" << is_class<t>::value << " is_empty=" << is_empty<t>::value << endl; template<typename T, typename... Args> void reflect_compiler_reflect(t value, Args... args) reflect_compiler_reflect(value); reflect_compiler_reflect(args...); int main() int a = 1; float b = 4.5f; double c[71]; string d; auto e = [] (int a) ; auto f = std::bind(e, 99, _1); struct g; reflect_compiler_reflect(a, b, c, d, e, f, g);

22 User-defined literals Allow definition of type safe SI units and other creative uses Solve Mars Climate Orbiter type problems class Symbol public: string name; Symbol(const char *name) : name(name) ; Symbol operator "" _symbol(const char* name, size_t) return Symbol(name); int main() Symbol Foo = "Foo"_symbol;

23 More functional lambdas [], [=], [&] use in place of old-style function objects combine with existing STL generic algorithms e.g. std::partition currying std::function std::bind std::placeholders::_1

24 Lots more STL Compile time reflection <type_traits> Containers <array>, <unordered_set>, <unordered_map>, <forward_list> Multi-threading <atomic>, <thread>, <mutex>, <future>, <condition_variable> More utility <tuple>, <regex>, <chrono>, <codecvt> Numerics <random>, <ratio>, <cfenv>

25 C++14 Generic lambdas lambda initializers Variable templates make_unique Runtime sized arrays auto lambda = [](auto x, auto y) return x + y;; auto lambda = [value = 1] return value;; template<typename T> constexpr T pi = T( ); auto u = make_unique<some_type>(ctor, params); void foo(size_t n) int a[n]; Filesystem (Boost::filesystem) Networking

26 LLVM / Clang Modular compiler toolchain 2012 ACM Software System Award Clang memory sanitizer Clang address sanitizer Clang thread sanitizer Clang modernize Firefox - emscripten C++ to asm.js Chrome - PNaCl C++ LLVM bitcode Foundation of many OpenCL implementations

27 C++ - pros Maturity and Performance 30 years of evolution and production use in large scale systems ~ 2x - 3x faster than Java ~ 10x - 100x faster than Ruby and Python Compiler and architecture choices GCC 4.9, Clang 3.4, Intel C++ 14, Visual C , etc Easy access to processor features SSE4 Streaming Extensions, AVX-512 SIMD Vector Extensions Compile time static checking and type safety Static analysis tools, valgrind, clang memory sanitizer, Multi-paradigm Offers a choice of programming styles

28 C++ - cons Big language, big learning curve Define an idiom with C++: google c++ style Long compile times Idea is to spend time now to save it in the future Missing standard libraries networking, database, graphics, sound, xml and json serialization, etc The cost of runtime performance Buffer overflows,illegal memory accesses Requires static analysis Potential solution: Intel MPX (Memory Protection Extensions)

29 Conclusion Pick the right language for the job C++ is suitable for infrastructure code where performance and type safety are important C++ requires care with memory management (leaks, buffer offer-flows, off-by-one errors) Give C++ a go

30 Comments / Questions