By Adrien Hamelin | Apr 13, 2020 11:00 AM | Tags: c++17
Different compromise.
Runtime Polymorphism with std::variant and std::visit
by Bartlomiej Filipek
From the article:
Runtime polymorphism usually connects with v-tables and virtual functions. However, in this blog post, I’ll show you a modern C++ technique that leverages std::variant and std::visit. This C++17 technique might not only offer better performance and value semantics, but also interesting design patterns...
By Adrien Hamelin | Apr 13, 2020 10:55 AM | Tags: c++20
The series continue.
C++20: An Infinite Data Stream with Coroutines
by Rainer Grimm
From the article:
My story to coroutines in C++20 goes on. Today I dive deep into the coroutines framework to create an infinite data stream. Consequentially, you have to read the two previous posts "C++20: Coroutines - A First Overview", and "C++20: More Details to Coroutines" to be prepared...
By Szilard Szaloki | Apr 9, 2020 10:25 AM | Tags: None
Part2 of Fundamental operations on type lists is now available, featuring common template metaprogramming idioms, like multiple inheritance and the void* trick, demonstrated on simple metafunctions, such as push_front<>, push_back<>, pop_front<> and pop_back<>.
Fundamental operations on type lists (Part2)
by Szilard Szaloki
From the article:
Among the simplest metafunctions are
push_front<>andpush_back<>, since they can be easily implemented by leveraging C++11's parameter pack expansion...
By Szilard Szaloki | Apr 8, 2020 12:37 PM | Tags: None
Check out this article on basic C++ template metaprogramming concepts, such as type lists and metafunctions. This post also elaborates on alias templates and their limitations,
presents different approaches to implementing four fundamental metafunctions (first<>, front<>, last<> and back<>) and introduces a common metaprogramming primitive: apply<>.
Fundamental operations on type lists (Part1)
by Szilard Szaloki
From the article:
One of the fundamental building blocks of template metaprogramming is type lists. Dealing with them used to be a hassle, but since C++11 they are pretty much built into the language through type template parameter packs...
By Hitesh Kumar | Apr 8, 2020 12:00 PM | Tags: None
A comparison of string_view and span.
Differences between std::string_view and std::span
by nextptr
From this article:
As for the differences between the two, the std::span<T> is a general-purpose array view template, whereas the std::string_view is a more specialized view on a char sequence or string.
By Adrien Hamelin | Apr 6, 2020 11:31 AM | Tags: c++20
Understand them to be able to use them.
C++20: More Details to Coroutines
by Rainer Grimm
From the article:
My job in this and further posts is to explain the framework for building coroutines. On the end, you can create your own or using an existing implementation of coroutines such as the excellent one cppcoro from Lewis Baker.
Today's post is in-between: This post is not an overview but also not in-depth dive into the coroutines framework that follows in the next posts.
The first question you may have is: When should I use coroutines?
By Adrien Hamelin | Apr 6, 2020 11:20 AM | Tags: c++20 c++17
Not so easy.
Implementing span's comparisons
by Barry Revzin
From the article:
One of the new types in C++20 is std::span<T> (with its fixed- size counterpart std::span<T, N>). This is a very useful type, since it’s a type-erased view onto a contiguous range - but unlike more typical type erasure (e.g. std::function), there’s no overhead. I’ve previous written about span here.
In the initial design, std::span<T> had comparison operators that performed a deep comparison. Those operators were subsequently removed. I think that removal was a mistake, since these operators are very useful (as in, we have a span-like type in our codebase and we use these operators), but this blog isn’t going to be about why they were removed or why they should be added back.
Instead, this blog is about how to implement span’s comparison operators, since I think that is interesting and demonstrates a bunch of C++20 features all in one go. You can jump straight to the C++20 implementation here or you can just directly add it to your code base using my span_ext repo here...
By Adrien Hamelin | Apr 6, 2020 11:15 AM | Tags: efficiency
An interesting solution.
C++ pass-thru parameters
by Marius Elvert
From the article:
So in ye olde days, before C++11 and move semantics, it was common for functions to use mutable references to pass container-content to the caller...
By Adrien Hamelin | Mar 31, 2020 12:12 PM | Tags: community
Another point of view.
Kafka’s uncle spends a week with Les Booloise: Prague trip report
by Guy Davidson
From the article:
I love Czechia and I love Prague. I have visited a few times: most recently to give a talk at the Avast meetup last February, organised by Hana Dusíková, who also organised this WG21 meeting. She did an absolutely outstanding job, and I know that I share that opinion with many committee folk.
Of course, this was the meeting that C++20 was due to be signed off by WG21 and sent for polling by the National Bodies (NB) before going to ISO for publication. Plenty of time was spent on attending to outstanding NB comments but there was still scope for reviewing new proposals.
On top of that, there was a social event on Wednesday evening to celebrate the release, which took place at Pražská Křižovatka. The whole week was as tiring as ever, but I was delighted to be there, to make “the team photo” and to advance some of my work. If you are interested in a detailed report of the work completed you can find one on reddit: I am going to discuss my work and experiences...
By Adrien Hamelin | Mar 31, 2020 12:02 PM | Tags: c++20
Learn about the close future.
Requires-clause
by Andrzej Krzemieński
From the article:
In this post we will talk about another C++20 feature related to constraining templates: requires-clause. Although C++20 is due to be published this year, it is not there yet; so we are talking about the future. However, this can already be tested in trunk versions of GCC and Clang online in Compiler Explorer...