November 2012

Rule of Zero—R. Martinho Fernandes

Long-time C++98 developers know about the Rule of Three. But with C++11's addition of move semantics, we need to be talking instead about the Rule of Five.

This article argues for limiting the use of the Rule of Five, and instead mostly aiming for a "Rule of Zero" -- why you don't have and don't want to write logic for copying, for moving, and for destruction all the time in C++, and why you should encapsulate that logic as much as possible in the remaining situations when you actually need to write it. (And, in passing, he shows once again why C++11 developers seem to be drawn to reusing unique_ptrs with custom deleters like moths to flames bees to flowers. See also recent examples like this one on std-proposals.)

Rule of Zero

In C++ the destructors of objects with automatic storage duration are invoked whenever their scope ends. This property is often used to handle cleanup of resources automatically in a pattern known by the meaningless name RAII.

An essential part of RAII is the concept of resource ownership: the object responsible for cleaning up a resource in its destructor owns that resource. Proper ownership policies are the secret to avoid resource leaks...

Continue reading...

New site feature: Suggest an article

This site hosts a curated blog that provides pointers to the best and latest content in the world on modern Standard C++. From links to fresh new articles and books, to product news, to useful videos and events, to (of course) news about the standardarization process itself, we want you to be able to find out about it from here.

We want to link to all high-quality C++ content. But how can we make sure we don't miss something good? The blog editors know about a lot of the latest news and content, but no one person or small group can catalog it all, and we don't want to miss anything that C++ developers might find good and useful.

You can help. It's easy, and here's how.

Have you recently come across a high-quality article? a useful video? an upcoming event? cool product news? or something else likely of interest to a large subset of C++ developers? Then let us know using a cool new feature of the site: The "Suggest an Article" link available at the top right of the screen whenever you're logged into the site. (If you don't have a login, it's easy to get one: Registration is free.)

When you click on the Suggest link, you'll be taken to a screen that looks something like this. Here, you can write a draft blog post for the Blog Editors' consideration:

  • Enter a title, and the URL people should be taken to.
  • Pick an appropriate category.
  • Write a body that lets people know what it's about and why they should read/watch/follow the link.

As a guide, follow the style of existing blog posts already on this site. If you're curious, you can also check out the style guide used by our own editors; a subset of those features are available to you when writing blog suggestions.

You can make multiple suggestions and track their status via the Your Suggestions box on the right side of the suggestion page.

We can't accept all suggestions; some will be duplicates, others may not be deemed to be of wide enough interest to C++ developers. But many suggestions will be accepted -- if your post is accepted, the editors will edit it to tighten it up and conform to our style guide, and post it live for the world to see and appreciate with your name in the byline as the author of the blog post. If that happens to your suggestion, congratulations -- that's your name up there in bright lights on the home page of!

A few of you already found the Suggest link, and so we're happy to report that the very first user blog post suggestion by Blair Davidson went live today. Thanks, Blair, and thanks in advance to all who will help us find and link to the best high-quality C++ content in the world.

C++ Questions and Answers—Herb Sutter

This blog post was suggested by Blair Davidson. The video is from summer 2011, shortly before the C++11 standard was ratified:

Herb Sutter: C++ Questions and Answers

Jun 07, 2011

Herb's [previous] appearance on C9 was a relatively short chat with me about C++0x. You wanted more questions asked and some of you thought I was just too soft on Herb. Well, Herb decided that the best way to get the questions you want asked is, well, to have you ask them. Most of the highest user-rated questions were asked and Herb answers with his usual precision. So, without further ado, it's C++ question and answer time with Herb Sutter, powered by you.

Continue reading...

scope(exit) in C++11

A C++ note in passing from an indie game developer. He notes that Boost has a similar feature already (see the BOOST_SCOPE_EXIT macros and discussion of alternatives) but likes that you can write the basic feature yourself in under 10 lines, have it work like a statement instead of a BEGIN/END macro pair, and use it with other C++11 features like lambdas.

scope(exit) in C++11

I really like the scope(exit) statements in D. They allow you to keep the cleanup code next to the initialization code making it much easier to maintain and understand. I wish we had them in C++.

Turns out this can be implemented easily using some of the new C++ features...

Continue reading...

Storage Layout of Polymorphic Objects—Dan Saks

It's great to see Dan writing about C++ again. Here's his latest today, in Dr. Dobb's:

Storage Layout of Polymorphic Objects

By Dan Saks

Adding at least one virtual function to a class alters the storage layout for all objects of that class type.

Adding at least one virtual function to a class alters the storage layout for all objects of that class type. In this article, I begin to explain how C++ compilers typically implement virtual functions by explaining how the use of virtual functions affects the storage layout for objects.

Continue reading...

(Not) Using std::thread—Andrzej KrzemieĊ„ski

Andrzej Krzemieński writes:

(Not) using std::thread

This post is about std::thread but not about threads or multi-threading. This is not an introduction to C++ threads. I assume that you are already familiar with Standard Library components thread and async.

I encountered a couple of introductions to C++ threads that gave a code example similar to the one below:

void run_in_parallel(function<void()> f1, function<void()> f2)


    thread thr{f1}; // run f1 in a new thread

    f2();           // run f2 in this thread

    thr.join();     // wait until f1 is done


While it does give you a feel of what thread’s constructor does and how forking and joining works, I feel it does not stress enough how exception-unsafe this code is, and how unsafe using naked threads in general is. In this post I try to analyze this “safety” issues...

Continue reading...

SG4 (Networking) wiki online

Study Group 4 (SG4), which focuses on Networking topics, now has a wiki on GitHub for those who want to follow its work and near-term deliverables.

The link is also available via SG4's entry in the SG list on The Committee page.

Please contact the SG4 chair, Kyle Kloepper, for further information.

Reactive Extensions (Rx) now supports LINQ in C++, goes open source

Reactive Extensions (Rx) is now open source and supports LINQ styles in C++.

From the announcement, Rx is already being used for a number of highly responsive applications including GitHub for Windows:

According to Paul Betts at GitHub, "GitHub for Windows uses the Reactive Extensions for almost everything it does, including network requests, UI events, managing child processes (git.exe). Using Rx and ReactiveUI, we've written a fast, nearly 100% asynchronous, responsive application, while still having 100% deterministic, reliable unit tests. The desktop developers at GitHub loved Rx so much, that the Mac team created their own version of Rx and ReactiveUI, called ReactiveCocoa, and are now using it on the Mac to obtain similar benefits."

In addition to Rx's original support for .NET and new support for Javascript, Rx has also added support for C++:

Rx++: The Reactive Extensions for Native (RxC) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in both C and C++.

Ix++: An implementation of LINQ for Native Developers in C++.

Where to download or find out more:

On the Superfluousness of std::move—Scott Meyers

Scott answers reader questions about whether std::move is superfluous... couldn't one size of std::forward fit well enough on everyone?

On the Superfluousness of std::move

Scott Meyers

During my presentation of "Universal References in C++11" at C++ and Beyond 2012, I gave the advice to apply std::move to rvalue reference parameters and std::forward to universal reference parameters.  In this post, I'll follow the convention I introduced in that talk of using RRef for "rvalue reference" and URef for "universal reference."

Shortly after I gave the advice mentioned above, an attendee asked what would happen if std::forward were applied to an RRef instead of std::move.  The question took me by surprise.  I was so accustomed to the RRef-implies-std::move and URef-implies-std::forward convention, I had not thought through the implications of other possibilities.  The answer I offered was that I wasn't sure what would happen, but I didn't really care, because even if using std::forward with an RRef would work, it would be unidiomatic and hence potentially confusing to readers of the code.

The question has since been repeated on stackoverflow, and I've also received it from attendees of other recent presentations I've given.  It's apparently one of those obvious questions I simply hadn't considered.  It's time I did.

Continue reading...

CGAL 4.1 released (Computational Geometry Algorithms Library)

The CGAL Open Source Project is pleased to announce the release 4.1 of CGAL, the Computational Geometry Algorithms Library.

Besides fixes to existing packages, the following has changed since CGAL 4.0:

  • New compiler support: the Apple Clang compiler versions 3.1 and 3.2 are now supported on Mac OS X.

See for a complete list of changes.

The CGAL project is a collaborative effort to develop a robust, easy-to-use, and efficient C++ software library of geometric data structures and algorithms, like

  • triangulations (2D constrained triangulations and Delaunaytriangulations in 2D and 3D, periodic triangulations),
  • Voronoi diagrams (for 2D and 3D points, 2D additively weighted Voronoi diagrams, and segment Voronoi diagrams),
  • Boolean operations on polygons and polyhedra,
  • regularized Boolean operations on polygons with curved arcs
  • arrangements of curves,
  • mesh generation (2D, 3D and surface mesh generation, surface mesh subdivision and parametrization),
  • alpha shapes (in 2D and 3D),
  • convex hull algorithms (in 2D, 3D and dD),
  • operations on polygons (straight skeleton and offset polygon),
  • search structures (kd trees for nearest neighbor search, and range and segment trees),
  • interpolation (natural neighbor interpolation and placement of streamlines),
  • optimization algorithms (smallest enclosing sphere of points or spheres, smallest enclosing ellipsoid of points, principal component analysis),
  • kinetic data structures

Some modules are distributed under the terms of the LGPL Open Source license (GNU Lesser General Public License v3 or later versions). Most modules are distributed under the terms of the GPL Open Source license (GNU General Public License v3 or later versions). If your intended usage does not meet the criteria of the aforementioned licenses, a commercial license can be purchased from GeometryFactory.

For further information and for downloading the library and its documentation, please visit the CGAL web site.