Articles & Books

Trip Report: Fall ISO C++ Meeting

 

The fall ISO C++ meeting was held on November 3-8 in Urbana-Champaign, IL, USA. Many thanks again to Riverbed Technology and the University of Illinois at Urbana-Champaign for hosting us!

As usual, we met for six days, starting Monday morning and ending on Saturday afternoon. This week was especially action-packed, and we had working sessions around the clock continuously from 9:00am Monday until 3:00pm Saturday, with the only breaks being short lunch and dinner breaks, and roughly 10pm-8am for sleep and breakfast (though, also as usual, many paper authors whose proposals were making progress opted to spend part of their sleep time updating their papers).

This is the first meeting since C++14 was officially completed, and so this was the first “C++17 era” meeting. We adopted a number of proposals directly into the C++ working draft that will become C++17, and adopted other proposals into other Technical Specifications that are developing independently from the core standard and may be folded into the C++ standard itself in the future.

Sadly, this was the last meeting for retiring long-time U.S. committee chair Steve Clamage who has done a tireless and much-appreciated job herding the cats for the past 20 or so years. Steve is one of the five remaining original members of the ISO C++ committee who had attended the first ISO C++ organizational meeting back in 1989 and has still been attending up to this month's meeting; the others are Pete Becker, Mike Miller, Tom Plum, and Bjarne Stroustrup. Thanks again, Steve, for all your contributions to ISO C++, and happy retirement! The new chair of the U.S. committee is Clark Nelson, who has long served as vice-chair. In turn, the new vice-chair is John Spicer.

Milestones

Four major milestones were achieved that will result in issuing four ISO ballots:

  • The Transactional Memory TS was approved to be sent out for its primary comment ballot, known as PDTS ballot. This is the first of two ballot stages for a TS.
  • The Parallelism TS was approved to be sent out for its final ballot, known as DTS ballot.
  • The Library Fundamentals TS was approved to be sent out for its final DTS ballot.
  • Also, in what amounts to a ribbon-cutting ceremony, I was also directed to officially request a New Work Item for the next C++ standard itself, which is expected to be C++17.

We adopted a number of proposals, which are covered in the following isocpp.org posts:

Happily, at least for me, two of my own proposals were adopted at this meeting.

First, Andrei Alexandrescu inspired me to write and pursue what became adopted via paper N4259, to add the new function int std::uncaught_exceptions() noexcept; to the standard library that returns the number of active exceptions in this thread. This will enable a portable ScopeGuard that can automatically detect success/failure without asking the user to write a manual .Dismiss() or forcing the ScopeGuard implementation to rely on undocumented compiler artifacts (which, ahem, Andrei’s implementation had been doing on GCC, Clang, and MSVC – figuring out where the compilers were already storing this very exception count information and doing the world’s most contorted reinterpret_cast<int*>s to get access to the count. I expect C++ implementations to implement this aggressively – in fact, I believe it was implemented for either libc++ or libstdc++ two days later. Finally, while they were at it, the committee also decided to deprecate the old std::uncaught_exception() which has long been known to be almost-but-not-quite what is wanted.

Second, Scott Meyers inspired and demonstrated the need for a name for T&& references – that is, where T is a template parameter type and the reference could “become” const or non-const, rvalue or lvalue. This is different enough that it, and more importantly its intended usage, needs a name. In the absence of a special name for this provided by the committee, Scott initially called these “universal references.” A number of experts agreed there should be a name, but that “forwarding references” was better, and Scott himself had used that term in the past. The committee agreed, and via N4262 has now added the term “forwarding reference” to the draft standard. As icing on the cake, not only is the term in normative text, but it’s promoted to a formal “term of power” that the draft standard itself now already uses in two places to replace the old longer phrase-that-really-needed-a-name. (We would have been satisfied with a non-normative note; it’s nifty that the committee itself found it useful to have a name for this thing to improve the specification of the standard itself.)

Many thanks again to Scott and Andrei for popularizing and demonstrating the need for these features and the form they could take in the standard.

I also presented my atomic smart pointers proposal, for atomic versions of unique_ptr, shared_ptr, and weak_ptr. These were accepted by the Concurrency subgroup (SG1), approved by the Library Evolution Group, and received initial wording review in the core Library Working Group. Hopefully this paper, or a minor update, will be ready to be adopted into the Concurrency TS at our next meeting in May.

Finally, I had proposed allowing a return statement to be allowed to call explicit constructors, and at our summer meeting in Rapperswil the Evolution Working Group agreed with allowing the syntax “return { /* whatever */ };” to invoke explicit constructors, and I got to final wording in the Core Working Group which is the last stage before it is brought before the full committee for approval. However, because this proved to be controversial in the larger group, I voluntarily withdrew the proposal – at least for the time being, and I don’t currently plan to bring it forward again.

Evening sessions

We had five evening sessions on specific topics of broad interest. Most were attended by a majority of the full committee.

On Monday evening, most of the committee spent three hours on coroutines and fibers. There were three major concurrency proposals related to smaller-than-thread concurrency such as resumable functions. At the end, the group expressed a strong direction to pursue coroutines and fibers (as strawman names) as distinct concurrency primitives, in addition to threads. Broadly, the key distinction is that a fiber enables cooperative scheduling of multiple stacks within a thread – that is, a fiber is a unit of work smaller than a thread but with its own stack, and that can be assigned to run on a thread; whereas a coroutine is an ultra-lightweight unit of work that is smaller still and does not have its own stack.

On Tuesday evening, we spent another three hours on contracts – preconditions, postconditions, and invariants. The group gave some direction on preferred directions and we expect to see updated proposal(s) for our next meeting.

On Wednesday evening, we spent two hours on ranges. Eric Niebler presented a design and prototype implementation for ranges and range-based algorithms, expressed using fully modern C++14 plus the Concepts TS language features, although it could be implemented without language support for Concepts. There was extensive Q&A and palpable excitement and a unianimous vote to encourage the author to return with proposed standardese wording that could be wordsmithed and hopefully adopted at a future meeting.

Thursday evening was devoted to pattern matching. This flexible set of facilities could provide a general framework that would subsume a number of other proposals, ranging from a more flexible form of the ordinary switch statement, possibly all the way to the “static if” style proposals.

Friday evening was devoted to reflection proposals, focusing on compile-time reflection facilities for C++. I left at 9:30, but later heard that the session continued nearly another two hours afterwards.

Next meetings

Our next full WG21 face-to-face meeting will be on May 4 to 9 in Lenexa, Kansas, USA.

In the meantime, over the winter we’ll be having several other smaller face-to-face and telecon meetings on specific topics.

  • The Concepts specification working paper will continue to be reviewed in two telecons in December and January, with a three-day face-to-face meeting on January 26-28 in Skillman, New Jersey, USA, at which we hope to approve the document to be sent out for its main comment ballot (PDTS). This meeting is being hosted by Bloomberg and Edison Design Group.
  • The Library groups will be holding a full-week face-to-face meeting on February 23-27 in Cologne, Germany to work specifically on the issues lists for the existing standard library at a meeting that is not also considering new features; think of it as a “bug bash” meeting. This meeting is being hosted by Josuttis Eckstein and ParStream.

Many thanks especially to the meeting hosts for graciously volunteering to organize these meetings!

 

C++14 for Qt programmers—Olivier Goffart

For those who know how to pronounce Qt, note that this title is not intended as a beauty judgment:

C++14 for Qt programmers

by Olivier Goffart

From the article:

C++14 is the name of the version of the standard to be released this year. While C++11 has brought many more feature that took time to be implemented by the compilers, C++14 is a much lighter change that is already implemented by compilers such as clang or gcc.

Qt 5 already was adapted in many ways so you can make use of the new features of C++11. You can read about that in my previous article. C++11 in Qt5. This article mention some of the changes in C++14 and the impact on Qt users...

Quick Q: Is it idiomatic to make X objects immutable by making all X member data const?—SO

Quick A: Yes.

Recently on SO:

Idiomatic way to declare C++ immutable classes

So I have some pretty extensive functional code where the main data type is immutable structs/classes. The way I have been declaring immutability is "practically immutable" by making member variables and any methods const.

struct RockSolid {
   const float x;
   const float y;
   float MakeHarderConcrete() const { return x + y; }
}

Is this actually the way "we should do it" in C++? Or is there a better way?

Quick Q: Which is more efficient, push_back(move(var)) or emplace_back(var)?—StackOverflow

Quick A: 1. Those cases are not equivalent. 2. Emplace is more for when you don't already have a named object of the correct type...

Recently on SO:

Efficiency of C++11 push_back() with std::move versus emplace_back() for already constructed objects

In C++11 emplace_back() is generally preferred (in terms of efficiency) to push_back() as it allows in-place construction, but is this still the case when using push_back(std::move()) with an already-constructed object?

For instance, is emplace_back() still preferred in cases like the following?

std::string mystring("hello world");
std::vector<std::string> myvector;

myvector.emplace_back(mystring);
myvector.push_back(std::move(mystring));
// (of course assuming we don't care about using the value of mystring after)

Additionally, is there any benefit in the above example to instead doing:

myvector.emplace_back(std::move(mystring));

or is the move here entirely redundant, or has no effect?

Quick Q: How do I make an array of shared_ptrs to unrelated types?—StackOverflow

Quick A: Try vector<shared_ptr<boost::any>>.

Recently on SO:

Array of shared pointers to different classes

I am new to c++11 programming and now I'm trying to figure out if it is possible to create an array of shared pointers to different types. For example, something like that:

vector<shared_ptr<**???**>> v;
v.push_back(shared_ptr<int>(new int));
v.push_back(shared_ptr<MyClass>(new MyClass()));

or any other way to pass shared_ptr without knowing its type.

Functional Programming in C++—John Carmack

In case you missed it:

Functional Programming in C++

by John Carmack

From the article:

... My pragmatic summary: A large fraction of the flaws in software development are due to programmers not fully understanding all the possible states their code may execute in. In a multithreaded environment, the lack of understanding and the resulting problems are greatly amplified, almost to the point of panic if you are paying attention. Programming in a functional style makes the state presented to your code explicit, which makes it much easier to reason about, and, in a completely pure system, makes thread race conditions impossible.

I do believe that there is real value in pursuing functional programming, but it would be irresponsible to exhort everyone to abandon their C++ compilers and start coding in Lisp, Haskell, or, to be blunt, any other fringe language...

Quick Q: What type do lambdas get compiled into?—StackOverflow

Quick A: A compiler-generated type that stores the captured variables in its data members, and exposes the function signature and body as its operator().

Recently on SO:

What type do lambdas get compiled into?

As I know all data types must be known at compile time, and lambda is not a type. Does lambda got translated into anonymous struct with operator() or std::function wrapped?

For example,

std::for_each(v.begin(), v.end(), [](int n&){n++;});

Tiny Metaprogramming Library—Eric Niebler

eric-niebler-toronto.PNGWe like to link to articles at all levels. This one's near the top of the scale, for those looking for a real challenge:

Tiny Metaprogramming Library

by Eric Niebler

As the intro says [emphasis ours]:

(Difficult-to-grok metaprogramming below. Not for the faint of heart.)

From the rest of the introduction:

At the recent Urbana-Champaign meeting of the C++ Standardization Committee, Bill Seymour presented his paper N4115: Searching for Types in Parameter Packs which, as its name suggests, describes a library facility for, uh, searching for a type in a parameter pack, among other things. It suggests a template called packer to hold a parameter pack:

// A class template that just holds a parameter pack:
template <class... T> struct packer { };

Many of you are probably already familiar with such a facility, but under a different name:

// A class template that is just a list of types:
template <class... T> struct typelist { };

It became clear in the discussion about N4115 that C++ needs a standard typelist template and some utilities for manipulating them. But what utilities, exactly? ...

What makes Clang so special?—CoderGears

Today on CoderGears:

What makes Clang so special?

by CoderGears Team

From the article:

It’s proven that Clang is a mature compiler for C and C++ as [are the] GCC and Microsoft compilers, but what makes it special is the fact that it’s not just a compiler. It’s also an infrastructure to build tools. Thanks to its library based architecture which makes the reuse and integration of functionality provided more flexible and easier to integrate into other projects...