Improve your C++ with Inspirations from other languages - Andreas Reischuck
A new video from Meeting C++ 2017:
Improve your C++ with Inspirations from other languages
by Andreas Reischuck
experimental
Chaining Comparisons: Seeking Information from the Audience--Barry Revzin
A nice example of committee members reaching out to the community for data/input on proposed changes that could have a breaking impact.
Chaining Comparisons: Seeking Information from the Audience
by Barry Revzin
From the article:
At the last standards committee meeting in Albuquerque, the spaceship operator was adopted into the working draft for what will eventually be C++20. I’m already pretty excited about that. But one of the initial “optional” parts of Herb Sutter’s original spaceship proposal (which was dropped early) was to support chaining comparisons...
Red Hat at the ISO C++ Standards Meeting (Nov 2017): Parallelism and Concurrency -- Torvald Riegel
Discover how C++ evolves:
Red Hat at the ISO C++ Standards Meeting (November 2017): Parallelism and Concurrency
by Torvald Riegel
From the article:
Several Red Hat engineers attended the JTC1/SC22/WG21 C++ Standards Committee meetings in November 2017. This post focuses on the sessions of SG1, the study group on parallelism and concurrency. SG1 had a full schedule as usual, with Executors, Futures, and deferred reclamation mechanisms (e.g., RCU) being major discussion topics. We also started to track the state of proposals and topics we will need to discuss in a publicly accessible bug tracker...
C++ Coroutines: Understanding operator co_await--Lewis Baker
An article very complete!
C++ Coroutines: Understanding operator co_await
by Lewis Baker
From the article:
In the previous post on Coroutine Theory I described the high-level differences between functions and coroutines but without going into any detail on syntax and semantics of coroutines as described by the C++ Coroutines TS (N4680).
The key new facility that the Coroutines TS adds to the C++ language is the ability to suspend a coroutine, allowing it to be later resumed. The mechanism the TS provides for doing this is via the new co_await operator.
Understanding how the co_await operator works can help to demystify the behaviour of coroutines and how they are suspended and resumed. In this post I will be explaining the mechanics of the co_await operator and introduce the related Awaitable and Awaiter type concepts.
But before I dive into co_await I want to give a brief overview of the Coroutines TS to provide some context...
Implementing the spaceship operator for optional--Barry Revzin
The future implementation?
Implementing the spaceship operator for optional
by Barry Revzin
From the article:
Last week, the C++ Standards Committee added operator<=>, known as the spaceship operator, to the working draft for what will eventually become C++20. This is an exciting new language feature for two reasons: it allows you to write one function to do all your comparisons where you used to have to write six, and it also allows you to write zero functions — just declare the operator as defaulted and the compiler will do all the work for you! Exciting times...
Meeting C++ 2017 Schedule published
The Schedule for Meeting C++ 2017 is live:
Meeting C++ 2017 Schedule
by Jens Weller
Overview:
For 3 days there is a keynote per day and 4 tracks in parallel of very good C++ Content.
Just C++ - dlib serialize & std::shared_ptr
New episode of Just C++, today on serializing shared_ptr with dlib
Just C++ - serializing dlib & std::shared_ptr
by Jens Weller
C++ Annotated: Apr – Aug 2017--Anastasia Kazakova
Did you miss something?
C++ Annotated: Apr – Aug 2017
by Anastasia Kazakova
From the article:
Today we are happy to share our next compilation of C++ news with you.
Ranges, Coroutines, and React: Early Musings on the Future of Async in C++ -- Eric Niebler
Eric Niebler shares his thoughts about the interaction of ranges and co-routines in his recent blog post.
Ranges, Coroutines, and React: Early Musings on the Future of Async in C++
by Eric Niebler
From the article:
Another way to look at this is that synchronous ranges are an example of a pull-based interface: the user extracts elements from the range and processes them one at a time. Asynchronous ranges, on the other hand, represent more of a push-based model: things happen when data shows up, whenever that may be. This is akin to the reactive style of programming.
By using ranges and coroutines together, we unify push and pull based idioms into a consistent, functional style of programming. And that’s going to be important, I think.
C++ Weekly Episode 76: static_print—Jason Turner
Episode 76 of C++ Weekly.
static_print
by Jason Turner
About the show:
In this episode Jason explores an experimental patch to gcc that allows for compile-time printing.