Oh, Baby, Give Me ++Chance

A Timid Defense Of C++(11)

Transcript

1. Oh, Baby, Give Me ++Chance ! A Timid Defense of C++(11) Andy Gross <@argv0> Chief Architect, Basho Technologies
2. “There are only two kinds of languages: the ones people complain about and the ones nobody uses” ! - Bjarne Stroustrup
3. “Within C++, there is a much smaller and cleaner language struggling to get out.” ! - Bjarne Stroustrup
4. C++ : The most misunderstood language • Cargo-culted snark: • templates are weird! • omg boost takes so long to compile • i’ll have to manually manage every memory allocation • gahhh derp derp herrrrrrrrp // hacker news
5. The Best C++ Feature • RAII: “Resource acquisition is initialization” • Crappy acronym, simple concept • Acquire resources in constructors, release them in destructors • Deterministic destruction does the rest • Java try-with-resources is an ugly hack
6. RAII struct lock_guard! {! lock_guard(mutex mtx)! : mtx_(mtx)! {! acquire_mutex(mtx_);! }! ! ~lock_guard()! {! release_mutex(mtx_);! }! ! mutex mtx_;! };!
7. RAII struct my_object! {! void do_something()! {! lock_guard g(mtx_);! do_something_with_state_that_might_throw(state_);! // mtx_ is released regardless of how function exits! }! mutex mtx_;! state state_;! };!
8. RAII struct my_other_obj! {! my_other_obj()! : myobj_(make_shared<my_object>()) {}! ! void do_something()! {! // acquires lock in my_object! myobj_.do_something()! }! ! // destroyed automaticaly when object goes out of scope! shared_ptr<my_object> myobj_;! };! ! int main(void)! {! auto o = std::make_shared<my_other_obj>();! o->do_something();! return 0;! }!
9. RAII template <typename T>! struct locked_queue ! {! typedef lock_guard<mutex> lock_guard;! ! locked_queue()! : q_(make_shared<queue>()) {}! ! void produce(const T& item)! {! lock_guard lock(mtx_);! q_.push(item);! }! ! void consume(T& item)! {! lock_guard lock(mtx_);! item = q_.front();! q_.pop();! }! ! private:! shared_ptr<queue<T>> q_;! mutex mtx_;! };!
10. Literal Containers void cpp03()! {! // the old crappy way! vector<int> my_ints;! for (int i=0;i<10;i++)! my_ints.push_back(i);! for (vector<int>::iterator it=my_ints.begin(); it != my_ints.end(); ++it)! cout << *it << endl;! }! ! void cpp11()! {! // how’d your literal initialization game come up?! vector<int> my_ints = {1,2,3,4,5,6,7,8,9,10};! // ayo java peep this:! for (auto i: my_ints)! cout << i << endl;! }! ! void literal_maps()! {! // maps and tuples too! map<string, string> my_map = {{"foo", "bar"}, {"baz", "quux"}};! ! tuple<string,string,int> = …;! }
11. Lambdas! void lambda_lambda_lambda();! {! auto my_simple_lambda = [](){ cout << "hello, world\n"; };! // prints "hello, world” ! my_simple_lambda();! int i = 0;! // captures i by copy! // prints 2, but i is unchanged in outer scope;! auto my_copy_capture_lambda = [i]() { i+=1; cout << i; };! my_copy_capture_lambda();! ! // captures i by copy! // prints i+y, i in outer scope is incremented by y! auto my_ref_capture_lambda = [&i](int y) { i+=y; cout << i; };! my_ref_capture_lambda();! ! // [&] = capture all by reference;! // [=] = capture all by copy! }!
12. Threads void thread_func()! {! a_long_calculation();! print_result();! }! ! ! int main(void)! {! thread t(thread_func);! t.join();! };!
13. Futures int main(void)! {! auto fut = async([](){ return a_long_calculation_returning_int(); });! // read hacker news! int x = fut.get();! };!
14. Constexpr // evaluated at compile time! constexpr int f(int x) { return x > 1 ? x * f(x - 1) : 1; }! ! int main(void)! {! // evaluated at compile time! cout << f(10) << endl;! ! int i = get_an_int_at_runtime();! ! // evaluated at runtime! cout << f(i) << endl;! }!
15. Other Goodies • nullptr : explicit null type, not convertible/ comparable to/with integral/boolean types • final/override keywords • static assertions • type traits • atomic types (atomic_[u]int[32|64])
16. Better Toolchain • clang vastly superior to gcc • comes with static analysis, AST introspection • even writing analysis plugins is reasonably simple • lldb > gdb too, once you relearn all the commands
17. Try It At Home • Assuming recent clang: • CXXFLAGS = “-std=c++11 -stdlib=libc++”
18. Conclusions • The combination of C++11 and the Clang toolchain makes C++ worth checking out again • Or maybe I just have Stockholm Syndrome? • … your thoughts or questions?