Home » Blog » Tags » experimental

experimental

Concepts Lite vs enable_if--Andrzej KrzemieĊ„ski

By Adrien Hamelin | Sep 22, 2016 01:12 PM | Tags: experimental community

Why having concepts?

Concepts Lite vs enable_if

by Andrzej Krzemieński

From the article:

This post contains quite advanced material. I assume you are already familiar with Concepts Lite. For an overview of what Concepts Lite is, I recommend this proposal. Also, I have found this blog very useful regarding the details of and issues with concepts’ mechanics. One could look at Concepts Lite as three features:

  1. A superior alternative to enable_if (or overload hiding).
  2. The subsumption relation that enables the additional control of partial ordering in the overload resolution process.
  3. A convenient tool for building compile-time predicates that check for valid types and expressions.

In this post I will only focus on the first feature, and try to answer the question, “what do we need Concepts Lite for, given that we already have std::enable_if (and SFINAE)?”

CppCon 2015 string_view--Marshall Clow

By Adrien Hamelin | Sep 9, 2016 11:46 AM | Tags: experimental efficiency

Have you registered for CppCon 2016 in September? Don’t delay – Registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2015 for you to enjoy. Here is today’s feature:

string_view

by Marshall Clow

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

The library fundamentals TS contains a new class "string_view", which appears to be unlike anything else in the standard library. In this talk, we will explore the uses of string_view, when it is appropriate to use it, and when it is not. Along the way, I will discuss other possible "_view" classes, with an eye to the upcoming "ranges" proposal before the standards committee.

CppCon 2015 Templator: Demo of a nice tool for Visualizing Template Instantiations--Peter Sommerlad

By Adrien Hamelin | Aug 29, 2016 11:22 AM | Tags: intermediate experimental community

Have you registered for CppCon 2016 in September? Don’t delay – Registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2015 for you to enjoy. Here is today’s feature:

Templator: Demo of a nice tool for Visualizing Template Instantiations

by Peter Sommerlad

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

Many C++ beginners shy away from employing templates in their code, because of the myth of templates being hard. Even seasoned C++ developers can have problems manually interpreting template code correctly as Olve Maudal's C++ pub quiz demonstrates. Overloads and template specializations make it hard for programmers and also IDEs to show a developer what happens without compiling a program and even with a compile one might not get, what actually happens unless an unintelligible error message from your compiler appears.

My students tried to alleviate that problem by visualizing template instantiation and overload selection in a C++ IDE and allow to navigate through template code in instantiation context that a compiler would only create internally and that is otherwise not available for humans. While still in its nascent state I hope to show what is possible and if things go as planned at the time of the submission you should be able to solve the template pub quiz questions without running the programs.

[C++17] Structured Bindings - Convert struct to a tuple (simple reflection)

By Adrien Hamelin | Aug 24, 2016 02:16 PM | Tags: intermediate experimental

An interesting piece of code!

[C++17] Structured Bindings - Convert struct to a tuple (simple reflection)

From the article:

Very simple approach to convert any struct (up to N members) to a tuple using C++17 structured bindings and the idea from Boost.DI (http://boost-experimental.github.io/di/cppnow-2016/#/7/11) used to detect type constructor traits.

Range-v3 on MSVC -- Eric Mittelette

By Felix Petriconi | Aug 24, 2016 01:45 AM | Tags: experimental c++14

The Visual C++ Team is delighted to announce that they just published a range-v3 implementation.

Range-v3 on MSVC is Available on GitHub

by Eric Mittelette

From the article:

This contribution comes hot on the heels of our recent work to improve expression SFINAE on our Visual Studio 2015 Update 3 VC++ compiler . This is the first implementation of the Range TS running in MSVC. In “Ranges for the Standard Library, Revision 1” (N4128) Ranges are defined like this: “A range is an object that refers to a sequence of elements, conceptually similar to a pair of iterators. One prime motivation for ranges is to give users a simpler syntax for calling algorithms.

CppCon 2015 C++ Atomics: The Sad Story of memory_order_consume--Paul E. McKenney

By Adrien Hamelin | Aug 5, 2016 01:52 PM | Tags: performance experimental

Have you registered for CppCon 2016 in September? Don’t delay – Registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2015 for you to enjoy. Here is today’s feature:

C++ Atomics: The Sad Story of memory_order_consume: A Happy Ending At Last?

by Paul E. McKenney

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

One of the big advantages of C++ atomics is that developers can now let the compiler know about the intent behind their multi-threaded synchronization mechanisms. At least they can tell the compiler as long as the synchronization mechanism in question is not RCU. You see, all production compilers promote RCU's memory_order_consume to memory_order_acquire. Although this promotion does ensure correctness, it also ensures the additional overhead of memory-barrier instructions on weakly ordered systems and of needlessly suppressed compiler optimizations on all systems.

All previous attempts to resolve this issue have foundered on either standard-committee reluctance to eviscerate the standard for a special case, compiler-writer reluctance to eviscerate their compilers for a special case, and kernel-developers reluctance to eviscerate their source base for late-to-the-party compiler support.

But now there is a glimmer of hope in the guise of a small set of small patches to the Linux kernel that eliminate the most challenging use cases. Will this hope be realized? Come to this talk to here the story, which by September will hopefully have a happy ending!

CppCon 2015 Concurrency TS Editor's Report--Artur Laksberg

By Adrien Hamelin | Aug 3, 2016 01:56 PM | Tags: performance experimental

Have you registered for CppCon 2016 in September? Don’t delay – Registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2015 for you to enjoy. Here is today’s feature:

Concurrency TS Editor's Report

by Artur Laksberg

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

In this presentation we will talk about the new C++ concurrency features that have been included in the Concurrency Technical Specification.

The TS should be of interest to anyone writing concurrent code in C++. The proposal includes improved futures for wait-free composition of asynchronous operations (including their relationship with C++ 'await'), new synchronization constructs as well as atomic smart pointers.