Home » Blog » Categories » Articles & Books

Articles & Books

C++ Rvalue References Explained--Thomas Becker

By Blog Staff | Oct 14, 2012 10:21 AM | Tags: intermediate basics

What are rvalue references and move semantics, and how do they work again, exactly?

If you haven't read Thomas Becker's nice explanation (or even if you have), be sure to check it out:

C++ Rvalue References Explained

Thomas Becker

1. Introduction
2. Move Semantics
3. Rvalue References
4. Forcing Move Semantics
5. Is an Rvalue Reference an Rvalue?
6. Move Semantics and Compiler Optimizations
7. Perfect Forwarding: The Problem
8. Perfect Forwarding: The Solution
9. Rvalue References and Exceptions
10. The Case of the Implicit Move
11. Acknowledgments and Further Reading

Parameter Types in Constructors -- Scott Meyers

By Blog Staff | Oct 12, 2012 12:23 PM | Tags: intermediate advanced

From the keyboard of Scott Meyers:

Parameter Types in Constructors

by Scott Meyers

I recently went through Sumant Tambe's presentation materials from his Silicon Valley Code Camp presentation, "C++11 Idioms."  He argues that an emerging idiom is to pass arguments to constructors by value, because this takes advantage of move opportunities when they are available.

I was surprised to read about this emerging idiom, in part because I had not heard of it (I'm supposed to be clued in about this kind of stuff) and in part because it runs contrary to my own thinking on the subject, which is to use perfect forwarding...

Using Strings in C++ Template Metaprograms -- Abel Sinkovics and Dave Abrahams

By Blog Staff | Oct 2, 2012 02:07 PM | Tags: advanced

Fresh off the press at C++ Next:

Using strings in C++ template metaprograms

by Abel Sinkovics and Dave Abrahams

Of all the reasons to love metaprogramming, probably the most compelling is that it lets us embed “little languages” in our programs... Instead of C++ expressions, of course, strings could be used to represent the DSL code snippet in the embedding C++ code. In fact, that’s an approach used by many “traditional” libraries:

auto all_caps = std::regex("[A-Z]+"); // OK

The only problem is, the contents of that string are only known at runtime, which means the language has to be interpreted at runtime, and we lose the benefit of being able to translate the structure into compiled code. The “delayed evaluation” has been delayed too long.

If, however, these strings could be parsed at compile-time, the resulting programs could have optimal performance again...

[more]

Unifying Generic Functions and Function Objects -- Dave Abrahams

By Blog Staff | Sep 26, 2012 03:53 AM | Tags: experimental advanced

From Dave Abrahams:

Unifying Generic Functions and Function Objects

I just got finished collaborating on a proposal with Faisal Vali and Herb Sutter to include generic lambdas and pythy functions in the core language. After the upcoming Portland committee meeting, we should have a good sense of how much appetite there is on the committee for including these features in C++.

While we were writing that paper, we got some of our most helpful comments and insights from Mathias Gaunard. It was a pivotal moment when Mathias reminded us that we could create operator overload sets explicitly with inheritance and using declarations, and then used it to demonstrate "overloaded lambda expressions..."

[more]

 

Padding and Rearranging Structure Members -- Dan Saks

By Blog Staff | Sep 20, 2012 02:17 PM | Tags: intermediate

Hot of the press at Dr. Dobb's:

Padding and Rearranging Structure Members

By Dan Saks

... Multibyte objects often have an alignment ... a "requirement that objects of a particular type be located on storage boundaries with addresses that are particular multiples of a byte address". The Standard leaves it up to each target processor to specify its alignment requirements. That is, a processor might require that a 4-byte integer or pointer referenced as a single object be word aligned — at an address that's a multiple of four. A processor also might require that an 8-byte floating-point number be word aligned, or maybe even double-word aligned — at an address that's a multiple of eight.

According to the C Standard, a program that attempts to access an improperly aligned object produces undefined behavior. This means that the program is in error, but the exact consequences of that error are platform-dependent. With many processors, an instruction that attempts to access improperly aligned data issues a trap. With other processors, an instruction that accesses misaligned data executes properly but uses up more cycles to fetch the data than if the data were properly aligned...

[more]

ASIO: Portable Stackless Coroutines in One* Header -- Chris Kohlhoff

By Blog Staff | Sep 17, 2012 09:01 AM | Tags: advanced

Via C++ Next, hat tip to Dave Abrahams:

Chris Kohlhoff’s ASIO library contains an extraordinary little header, not in the public interface, but in the examples directory, that implements what he calls “Stackless Coroutines” (very similar to Python’s Simple Generators if you’re familiar with those). He does it completely portably, with just a few macros, and considering that there are zero lines of platform-specific code, they work amazingly well.

Dave cites this article that describes how to use the coroutines:

A potted guide to stackless coroutines

Keen-eyed Asio users may have noticed that Boost 1.42 includes a new example, HTTP Server 4, that shows how to use stackless coroutines in conjunction with asynchronous operations. This follows on from the coroutines I explored in the previous three posts, but with a few improvements. In particular:

  • the pesky entry pseudo-keyword is gone; and
  • a new fork pseudo-keyword has been added.

The result bears a passing resemblance to C#'s yield and friends. This post aims to document my stackless coroutine API, but before launching into a long and wordy explanation, here's a little picture to liven things up...

User-Defined Literals, Part 1 -- Andrzej Krzemieński

By Blog Staff | Aug 20, 2012 09:20 AM | Tags: advanced

New article by Andrzej Krzemieński:

User-defined literals — Part I

This post is about the new language feature: the ability to specify user-defined literals. You may already be familiar with it, for example from N2750. In this post we will talk about literals in general, the purpose and usefulness of user-defined literals, their limitations, and alternatives in C++ to achieve similar goals.

[more]