November 2012

Post-Portland mailing available

The post-Portland mailing is now available. It includes meeting minutes, updated issues lists, and the papers adopted at this meeting (among other papers).

Of particular note is the Evolution Working Group paper status, now present again and maintained by Ville Voutilainen. Thanks, Ville!

 

WG21 Number PL22.16 Number Title Author Document Date Mailing Date Previous Version Subgroup Disposition
SD-1 12-0000R3 2012 PL22.16/WG21 document list Clark Nelson 2012-11-03 2012-11      
SD-2 12-0001R2 ISO WG21 and INCITS PL22.16 membership list Clark Nelson 2012-09-12 2012-09      
SD-3   SC22/WG21 (C++) Study Group Organizational Information Herb Sutter 2012-10-04 2012-09      
SD-5   WG21 and PL22.16 (C++) Joint Mailing and Meeting Information Herb Sutter 2010-09-20 2012-09      
N3453 12-0143 Minutes, WG21 Teleconference 2012-10-5 Kyle Kloepper 2012-10-5 2012-11      
N3454 12-0144 Minutes, WG21 Meeting No. 54, 15-19 October 2012 Portland, Oregon, USA Kyle Kloepper 2012-11-3 2012-11      
N3455 12-0145 Minutes, PL22.16 Meeting No. 59, 15-19 October 2012 Portland, Oregon, USA Kyle Kloepper 2012-11-3 2012-11      
N3456 12-0146 Range arguments for container constructors and methods, with wording Jeffrey Yasskin 2012-11-03 2012-11   Library  
N3457 12-0147 Algorithm std::iota and its modifications. Vladimir Grigoriev 2012-10-30 2012-11   Library  
N3458 12-0148 Simple Database Integration in C++11 Thomas Neumann 2012-10-22 2012-11   Library  
N3459 12-0149 Comparison of Two Database Access Methodologies Bill Seymour 2012-10-13 2012-11   Library  
N3462 12-0152 std::result_of and SFINAE E. Niebler, D. Walker, J. de Guzman 2012-10-18 2012-11 N3436= 12-0126 Library Adopted 2012-10
N3463 12-0153 Portable Program Source Files Beman Dawes 2012-11-02 2012-11   Evolution  
N3465 12-0155 Adding heterogeneous comparison lookup to associative containers for TR2 (Rev 2) Joaquín Mª López Muñoz 2012-10-29 2012-11 N2882= 09-0072 Library  
N3466 12-0156 More Perfect Forwarding Mike Spertus 2012-11-03 2012-11   Evolution  
N3467 12-0157 Runtime-sized arrays with automatic storage duration (revision 3) Jens Maurer 2012-10-29 2012-11 N3412= 12-0102 Core  
N3468 12-0158 User-defined Literals for Standard Library Types (version 2) Peter Sommerlad 2012-10-24 2012-11 N3402= 12-0092 Evolution  
N3469 12-0159 Constexpr Library Additions: chrono, v3 B. Kosnik, D. Krügler 2012-10-18 2012-11 N3303= 11-0073 Library Adopted 2012-10
N3470 12-0160 Constexpr Library Additions: containers, v2 B. Kosnik, D. Krügler 2012-10-18 2012-11 N3304= 11-0074 Library Adopted 2012-10
N3471 12-0161 Constexpr Library Additions: utilities, v3 B. Kosnik, D. Krügler 2012-10-18 2012-11 N3305= 11-0075 Library Adopted 2012-10
N3472 12-0162 Binary Literals in the C++ Core Language James Dennett 2012-10-19 2012-11   Core  
N3473 12-0163 C++ Standard Library Active Issues List (Revision R80) Alisdair Meredith 2012-11-03 2012-11 N3438= 12-0128 Library  
N3474 12-0164 C++ Standard Library Defect Report List (Revision R80) Alisdair Meredith 2012-11-03 2012-11 N3439= 12-0129 Library  
N3475 12-0165 C++ Standard Library Closed Issues List (Revision R80) Alisdair Meredith 2012-11-03 2012-11 N3440= 12-0130 Library  
N3477 12-0167 C++ Internet Protocol Classes A. Fabijanic, G. Obiltschnig 2012-10-28 2012-11   Networking  
N3478 12-0168 Core Issue 1512: Pointer comparison vs qualification conversions Jens Maurer 2012-10-29 2012-11   Core  
N3479 12-0169 Priority Queue, Queue and Stack: Changes and Additions G. Powell, T. Blechmann 2012-11-02 2012-11 N3443= 12-0133 Library  
N3480 12-0170 C++ Standard Core Language Active Issues, Revision 81 William M. Miller 2012-11-03 2012-11 N3382= 12-0072 Core  
N3481 12-0171 C++ Standard Core Language Defect Reports and Accepted Issues, Revision 81 William M. Miller 2012-11-03 2012-11 N3383= 12-0073 Core  
N3482 12-0172 C++ Standard Core Language Closed Issues, Revision 81 William M. Miller 2012-11-03 2012-11 N3384= 12-0074 Core  
N3484 12-0174 A URI Library for C++ G. Matthews, D. Berris 2012-11-01 2012-11 N3420= 12-0110 Networking  
N3485 12-0175 Working Draft, Standard for Programming Language C++ Stefanus Du Toit 2012-11-02 2012-11 N3376= 12-0066    
N3486 12-0176 C++ Editor's Report, October 2012 Stefanus Du Toit 2012-11-02 2012-11      
N3487 12-0177 TLS and Parallelism Pablo Halpern 2012-05-08 2012-11   Concurrency  
N3488 12-0178 Evolution Working Group paper status Ville Voutilainen 2012-11-02 2012-11   Evolution  
N3489 12-0179 A Rational Number Library for C++ Bill Seymour 2012-10-13 2012-11 N3414= 12-0104 Numerics  
N3490 12-0180 ADL Control for C++ Dave Abrahams 2012-10-31 2012-11   Evolution  
N3491 12-0181 Minutes: SG4 Networking, October 2012 Alex Fabijanic 2012-11-01 2012-11      
N3492 12-0182 Use Cases for Compile-Time Reflection (Rev. 2) Mike Spertus 2012-11-03 2012-11 N3403= 12-0093 Evolution  

Meeting C++ 2012: European C++ users group meeting

C++ continues to heat up with new conferences! Europeans now have something similar to C++ Now (formerly BoostCon), one organized and hosted by Europeans, but open to anyone:

Meeting C++ 2012

Nov 9-10, 2012, Düsseldorf/Neuss, Germany

Meeting C++ is being held with the collaboration of C++ Users Groups from Dusseldorf, Berlin, and Belgium. The inaugural conference already has over 175 attendees registered, and a rich talk list of current C+ topics. WG21's own Michael Wong will give a keynote on Good C++ Coding Style.

C++11: The New Standard -- Dave Abrahams

C++11 -- The New Standard

Dave Abrahams, BoostPro Computing

Contact info@boostpro.com for further details

 

In this class we’ll be using real C++11 compilers to explore the new standard, including these specific topics:

Classes: override and final, =default and =delete, in-class member initializers, delegating and inheriting constructors
Move Semantics: copy elision, rvalue references, and perfect forwarding
Concurrency: high- and low-level lock-based components. Atomics and the C++ memory model.
General: range-based for loops, nullptr, uniform initialization, string encodings, unicode, and auto
Functional: Lambda expressions, std::bind, std::function, user-defined literals, and constexpr
Exceptions: noexcept, nesting, copying, and re-throwing, system_error and friends
Containers: arrays, tuples, initializer_lists, emplacement, scoped allocators, and hash tables
Basic Types: standard-layout types, extended integer types, generalized unions, alignments, and scoped enums
Smart Pointers: unique_ptr, shared_ptr, weak_ptr, make_shared, allocate_shared
Templates: extended SFINAE, working with decltype and declval, and variadic templates

Because the earlier C++03 standard is familiar, and will still be relevant for many years, we offer special attention to future-proofing and to the emulation of C++11 features in C++03 using 3rd-party libraries such as Boost.

Who It’s For: experienced C++ programmers who want to be ready for C++11.

Format: Each day is divided roughly into four blocks, each consisting of an hour of lecture and thirty minutes of hands-on exercises. Ideally presented as a 5-day course, it is scalable to 3 days customized to your team’s needs.

Download a complete brochure (PDF) or contact info@boostpro.com for details.

 

Higher Level C++ with the Boost Libraries -- Dave Abrahams

Higher-Level C++ with the Boost Libraries

Dave Abrahams, BoostPro Computing

Contact info@boostpro.com for further details

The Boost library collection has become the de-facto standard toolkit for serious C++ development projects.

What You'll Get: new tools, revolutionary ideas, and a foundation upon which to continue expanding their knowledge.

Who It’s For: C++ developers who want to accelerate their work using high-quality infrastructure.

Format: Each day is divided roughly into four blocks, each consisting of an hour of lecture and thirty minutes of hands-on exercises. Ideally presented as a 5-day course, it is scalable to 3 days based on your team’s needs.

Structure: the scope of Boost is broad, so it is important to cover a subset of the collection that is both useful and relevant to your team. We will customize a selection of course modules that address your group’s needs, experience, and short- and long-term needs.

Suggested Course Modules

The modules below represent some suggested groupings of similar/related libraries, based on size, domain, and utility. Some libraries don’t fit neatly into one particular module, and the list of Boost libraries is constantly growing, so be sure to let us know if you want something you can't find here.

  • The Boost Core: presents a broad array of generally-useful libraries and introduces “vocabulary components and idioms” that are used throughout other libraries in Boost and in the C++11 standard. Recommended for all presentations of this course.
  • The Boost Graph Library: concepts, algorithms, data structures, theory and practice.
  • Computational Geometry with Boost: covers Boost.Geometry and Boost.Polygon.
  • Networking and Async Services: showcases Boost.ASIO and gets inside the “network programming head-space,” showing design patterns that can make this kind of code tight, maintainable, and efficient.
  • Boost Concurrency and HPC: covers both the issues inherent in concurrent systems and a suite of libraries in Boost that can help you solve them.
  • Algebraic Data Types: describes a highly-generic and introspectable way of working with data using the Boost Tuple, Variant, Optional, and Fusion libraries.
  • Image Processing: covers the powerful Boost.GIL library
  • Testing and Correctness: discover the Boost tools for writing rock solid code. Shows how to manage uncertainty and makes it possible to code with confidence.
  • Boost for Numerical Computing: covers the Boost.Math, Boost.Interval, Boost.Random, Boost.Accumulators and more, including several important offerings outside the Boost collection.
  • Functional Programming: aimed at C++03 programmers (who don’t have true lambda expressions) and at C++11 programmers desiring more power to create and manipulate functions.
  • Thinking Hybrid with Boost.Python: covers everything needed to flow smoothly between Python and C++, small- and large-scale development, extending Python, and embedding it in C++ programs.
  • Text Processing with Boost: develop fluency with the vocabulary of Boost's many text processing libraries and learn how to apply them effectively.
  • Metaprogramming Concepts and Frameworks: 
A compressed, high-intensity subset of our 5-day metaprogramming course, covering Boost.MPL, Boost.Fusion, and Boost.Proto, among others.

just::thread 1.8.2 released: C++11 thread library supports Ubuntu Quantal and Fedora 17

just::thread 1.8.2 is now available.

Anthony Williams' implementation of the C++11 threading library adds support for gcc 4.7.2, and consequently official support for Ubuntu Quantal and Fedora 17.

just::thread is now available for the following compilers:

  • Microsoft Visual Studio 2005, 2008, 2010 and 2012 for both 32-bit and 64-bit Windows,
  • TDM gcc 4.5.2 and 4.6.1 for both 32-bit and 64-bit Windows,
  • g++ 4.3, 4.4, 4.5, 4.6 and 4.7 (4.7.2 or later) for both 32-bit and 64-bit Linux (x86/x86_64), and
  • MacPorts g++ 4.3, 4.4, 4.5, 4.6 and 4.7 (4.7.2 or later) for 32-bit and 64-bit MacOSX.

Boost 1.52.0 released

Release 1.52.0 of the Boost C++ Libraries is now available.

These open-source libraries work well with the C++ Standard Library, and are usable across a broad spectrum of applications. The Boost license encourages both commercial and non-commercial use.

Releases 1.51.0 and 1.52.0 contain one new library (Boost.Context, by Oliver Kowalke) and numerous enhancements and bug fixes for existing libraries.

Here are some useful links for 1.52.0.

Many thanks to the Boost release team:

    Beman Dawes
    Daniel James
    Eric Niebler
    Marshall Clow
    Rene Rivera
    Vladimir Prus

We very much appreciate their continued hard work.

The Future of C++ -- Herb Sutter

Yesterday, many thousands of you were in the room or live online for Herb Sutter's talk, now available online:

The Future of C++

Herb Sutter
November 2, 2012

From Herb's video announcement summary:

This has been a phenomenal year for C++, since C++11’s publication just 12 months ago. And yesterday was a great day for C++.

Yesterday I had the privilege of announcing much of what Microsoft and the industry have been working on over the past year.

(minor) C++ at Microsoft

On September 12, we shipped VC++ 2012 with the complete C++11 standard library, and adding support for C++11 range-for, enum class, override and final. Less than two months later, yesterday we announced and shipped the November 2012 CTP, a compiler add-in to VC++ 2012 adding C++11 variadic templates, uniform initialization and initializer_lists, delegating constructors, function template default arguments, explicit conversion operators, and raw string literals. Details here, and download here.

Note that this is just the first batch of additional C++11 features. Expect further announcements and deliveries in the first half of 2013.

(major) C++ across the industry

Interest and investment in C++ continues to accelerate across the software world.

  • ISO C++ standardization is accelerating. Major companies are dedicating more people and resources to C++ standardization than they have in years. Over the next 24 months, we plan to ship three Technical Specifications and a new C++ International Standard.
  • C++ now has a home on the web at isocpp.org. Launched yesterday, it both aggregates the best C++ content and hosts new content itself, including Bjarne Stroustrup’s new Tour of C++ and Scott Meyers’ new Universal References article.
  • We now have a Standard C++ Foundation. Announced yesterday, it is already funded by the largest companies in the industry down to startups, financial institutions to universities, book publishers to other consortia, with more members joining weekly. For the first time in C++’s history since AT&T relinquished control of the language, we have an entity – a trade organization – that exists exclusively to promote Standard C++ on all compilers and platforms, and companies are funding it because the world runs on C++, and investing in Standard C++ is good business.

This is an exciting time to be part of our industry, on any OS and using any language. It’s especially an exciting time to be involved with C++ on all compilers and platforms.

Thank you all, whatever platform and language you use, for being part of it.

Links:

C++ coming back into the mainstream with more specs, more often -- Peter Bright

Peter Bright at Ars Technica:

C++ coming back into the mainstream with more specs, more often

Visual Studio 2012 standard conformance updates on the way.

At BUILD in Redmond today, Microsoft announced its plans to improve C++ standards conformance in its Visual Studio development environment, and talked about ways in which C++ would become a better, regularly updated, modern programming language. Microsoft developer and C++ standard committee secretary Herb Sutter introduced work being done by the C++ community to make the language better, and also discussed the work being done by Microsoft to make its own compiler better...

[Continue reading]

Universal References in C++11 -- Scott Meyers

Universal References in C++11

T&& Doesn’t Always Mean “Rvalue Reference”

by Scott Meyers

 

Related materials:

 

Perhaps the most significant new feature in C++11 is rvalue references; they’re the foundation on which move semantics and perfect forwarding are built. (If you’re unfamiliar with the basics of rvalue references, move semantics, or perfect forwarding, you may wish to read Thomas Becker’s overview before continuing.)

Syntactically, rvalue references are declared like “normal” references (now known as lvalue references), except you use two ampersands instead of one.  This function takes a parameter of type rvalue-reference-to-Widget:

void f(Widget&& param);

Given that rvalue references are declared using “&&”, it seems reasonable to assume that the presence of “&&” in a type declaration indicates an rvalue reference. That is not the case:

Widget&& var1 = someWidget;      // here, “&&” means rvalue reference

auto&& var2 = var1;              // here, “&&” does not mean rvalue reference

template<typename T>
void f(std::vector<T>&& param);  // here, “&&” means rvalue reference

template<typename T>
void f(T&& param);               // here, “&&”does not mean rvalue reference

In this article, I describe the two meanings of “&&” in type declarations, explain how to tell them apart, and introduce new terminology that makes it possible to unambiguously communicate which meaning of “&&” is intended. Distinguishing the different meanings is important, because if you think “rvalue reference” whenever you see “&&” in a type declaration, you’ll misread a lot of C++11 code.

The essence of the issue is that “&&” in a type declaration sometimes means rvalue reference, but sometimes it means either rvalue reference or lvalue reference. As such, some occurrences of “&&” in source code may actually have the meaning of “&”, i.e., have the syntactic appearance of an rvalue reference (“&&”), but the meaning of an lvalue reference (“&”).  References where this is possible are more flexible than either lvalue references or rvalue references. Rvalue references may bind only to rvalues, for example, and lvalue references, in addition to being able to bind to lvalues, may bind to rvalues only under restricted circumstances.[1]  In contrast, references declared with “&&” that may be either lvalue references or rvalue references may bind to anything.  Such unusually flexible references deserve their own name. I call them universal references.

The details of when “&&” indicates a universal reference (i.e., when “&&” in source code might actually mean “&”) are tricky, so I’m going to postpone coverage of the minutiae until later. For now, let’s focus on the following rule of thumb, because that is what you need to remember during day-to-day programming:

If a variable or parameter is declared to have type T&& for some deduced type T, that variable or parameter is a universal reference.

The requirement that type deduction be involved limits the situations where universal references can be found. In practice, almost all universal references are parameters to function templates. Because the type deduction rules for auto-declared variables are essentially the same as for templates, it’s also possible to have auto-declared universal references. These are uncommon in production code, but I show some in this article, because they are less verbose in examples than templates.  In the Nitty Gritty Details section of this article, I explain that it’s also possible for universal references to arise in conjunction with uses of typedef and decltype, but until we get down to the nitty gritty details, I’m going to proceed as if universal references pertained only to function template parameters and auto-declared variables.

The constraint that the form of a universal reference be T&& is more significant than it may appear, but I’ll defer examination of that until a bit later. For now, please simply make a mental note of the requirement.

Like all references, universal references must be initialized, and it is a universal reference’s initializer that determines whether it represents an lvalue reference or an rvalue reference:

  • If the expression initializing a universal reference is an lvalue, the universal reference becomes an lvalue reference.
  • If the expression initializing the universal reference is an rvalue, the universal reference becomes an rvalue reference.

This information is useful only if you are able to distinguish lvalues from rvalues.  A precise definition for these terms is difficult to develop (the C++11 standard generally specifies whether an expression is an lvalue or an rvalue on a case-by-case basis), but in practice, the following suffices:

  • If you can take the address of an expression, the expression is an lvalue.
  • If the type of an expression is an lvalue reference (e.g., T& or const T&, etc.), that expression is an lvalue. 
  • Otherwise, the expression is an rvalue.  Conceptually (and typically also in fact), rvalues correspond to temporary objects, such as those returned from functions or created through implicit type conversions. Most literal values (e.g., 10 and 5.3) are also rvalues.

Consider again the following code from the beginning of this article:

Widget&& var1 = someWidget;
auto&& var2 = var1;

You can take the address of var1, so var1 is an lvalue.  var2’s type declaration of auto&& makes it a universal reference, and because it’s being initialized with var1 (an lvalue), var2 becomes an lvalue reference.  A casual reading of the source code could lead you to believe that var2 was an rvalue reference; the “&&” in its declaration certainly suggests that conclusion.  But because it is a universal reference being initialized with an lvalue, var2 becomes an lvalue reference.  It’s as if var2 were declared like this:

Widget& var2 = var1;

As noted above, if an expression has type lvalue reference, it’s an lvalue.  Consider this example:

std::vector<int> v;
...
auto&& val = v[0];               // val becomes an lvalue reference (see below)

val is a universal reference, and it’s being initialized with v[0], i.e., with the result of a call to std::vector<int>::operator[]. That function returns an lvalue reference to an element of the vector.[2]   Because all lvalue references are lvalues, and because this lvalue is used to initialize val, val becomes an lvalue reference, even though it’s declared with what looks like an rvalue reference.

I remarked that universal references are most common as parameters in template functions.  Consider again this template from the beginning of this article:

template<typename T>
void f(T&& param);               // “&&” might mean rvalue reference

Given this call to f,

f(10);                           // 10 is an rvalue

param is initialized with the literal 10, which, because you can’t take its address, is an rvalue.  That means that in the call to f, the universal reference param is initialized with an rvalue, so param becomes an rvalue reference -- in particular, int&&.

On the other hand, if f is called like this,

int x = 10;
f(x);                            // x is an lvalue

param is initialized with the variable x, which, because you can take its address, is an lvalue.  That means that in this call to f, the universal reference param is initialized with an lvalue, and param therefore becomes an lvalue reference -- int&, to be precise.

The comment next to the declaration of f should now be clear:  whether param’s type is an lvalue reference or an rvalue reference depends on what is passed when f is called.  Sometimes param becomes an lvalue reference, and sometimes it becomes an rvalue reference.  param really is a universal reference.

Remember that “&&” indicates a universal reference only where type deduction takes place.  Where there’s no type deduction, there’s no universal reference.  In such cases, “&&” in type declarations always means rvalue reference.  Hence:

template<typename T>
void f(T&& param);               // deduced parameter type ⇒ type deduction;
                                 // && ≡ universal reference

template<typename T>
class Widget {
    ...
    Widget(Widget&& rhs);        // fully specified parameter type ⇒ no type deduction;
    ...                          // && ≡ rvalue reference
};

template<typename T1>
class Gadget {
    ...
    template<typename T2>
    Gadget(T2&& rhs);            // deduced parameter type ⇒ type deduction;
    ...                          // && ≡ universal reference
};

void f(Widget&& param);          // fully specified parameter type ⇒ no type deduction;
                                 // && ≡ rvalue reference

There’s nothing surprising about these examples.  In each case, if you see T&& (where T is a template parameter), there’s type deduction, so you’re looking at a universal reference.  And if you see “&&” after a particular type name (e.g., Widget&&), you’re looking at an rvalue reference.

I stated that the form of the reference declaration must be “T&&” in order for the reference to be universal. That’s an important caveat.  Look again at this declaration from the beginning of this article:

template<typename T>
void f(std::vector<T>&& param);     // “&&” means rvalue reference

Here, we have both type deduction and a “&&”-declared function parameter, but the form of the parameter declaration is not “T&&”, it’s “std::vector<t>&&”.  As a result, the parameter is a normal rvalue reference, not a universal reference.  Universal references can only occur in the form “T&&”!  Even the simple addition of a const qualifier is enough to disable the interpretation of “&&” as a universal reference:

template<typename T>
void f(const T&& param);               // “&&” means rvalue reference

Now, “T&&” is simply the required form for a universal reference.  It doesn’t mean you have to use the name T for your template parameter:

template<typename MyTemplateParamType>
void f(MyTemplateParamType&& param);  // “&&” means universal reference

Sometimes you can see T&& in a function template declaration where T is a template parameter, yet there’s still no type deduction.  Consider this push_back function in std::vector:[3]

template <class T, class Allocator = allocator<T> >
class vector {
public:
    ...
    void push_back(T&& x);       // fully specified parameter type ⇒ no type deduction;
    ...                          // && ≡ rvalue reference
};

Here, T is a template parameter, and push_back takes a T&&, yet the parameter is not a universal reference!  How can that be?

The answer becomes apparent if we look at how push_back would be declared outside the class. I’m going to pretend that std::vector’s Allocator parameter doesn’t exist, because it’s irrelevant to the discussion, and it just clutters up the code.  With that in mind, here’s the declaration for this version of std::vector::push_back:

template <class T>
void vector<T>::push_back(T&& x);

push_back can’t exist without the class std::vector<T> that contains it.  But if we have a class std::vector<T>, we already know what T is, so there’s no need to deduce it.

An example will help.  If I write

Widget makeWidget();             // factory function for Widget
std::vector<Widget> vw;
...
Widget w;
vw.push_back(makeWidget());      // create Widget from factory, add it to vw

my use of push_back will cause the compiler to instantiate that function for the class std::vector<Widget>. The declaration for that push_back looks like this:

void std::vector<Widget>::push_back(Widget&& x);

See?  Once we know that the class is std::vector<Widget>, the type of push_back’s parameter is fully determined:  it’s Widget&&.  There’s no role here for type deduction.

Contrast that with std::vector’s emplace_back, which is declared like this:

template <class T, class Allocator = allocator<T> >
class vector {
public:
    ...
    template <class... Args>
    void emplace_back(Args&&... args); // deduced parameter types ⇒ type deduction;
    ...                                // && ≡ universal references
};

Don’t let the fact that emplace_back takes a variable number of arguments (as indicated by the ellipses in the declarations for Args and args) distract you from the fact that a type for each of those arguments must be deduced.  The function template parameter Args is independent of the class template parameter T, so even if we know that the class is, say, std::vector<Widget>, that doesn’t tell us the type(s) taken by emplace_back.  The out-of-class declaration for emplace_back for std::vector<Widget> makes that clear (I’m continuing to ignore the existence of the Allocator parameter):

template<class... Args>
void std::vector<Widget>::emplace_back(Args&&... args);

Clearly, knowing that the class is std::vector<Widget> doesn’t eliminate the need for the compiler to deduce the type(s) passed to emplace_back.  As a result, std::vector::emplace_back’s parameters are universal references, unlike the parameter to the version of std::vector::push_back we examined, which is an rvalue reference.

A final point is worth bearing in mind: the lvalueness or rvalueness of an expression is independent of its type. Consider the type int.  There are lvalues of type int (e.g., variables declared to be ints), and there are rvalues of type int (e.g., literals like 10).  It’s the same for user-defined types like Widget. A Widget object can be an lvalue (e.g., a Widget variable) or an rvalue (e.g., an object returned from a Widget-creating factory function). The type of an expression does not tell you whether it is an lvalue or an rvalue.
Because the lvalueness or rvalueness of an expression is independent of its type, it’s possible to have lvalues whose type is rvalue reference, and it’s also possible to have rvalues of the type rvalue reference:

Widget makeWidget();                       // factory function for Widget

Widget&& var1 = makeWidget()               // var1 is an lvalue, but
                                           // its type is rvalue reference (to Widget)

Widget var2 = static_cast<Widget&&>(var1); // the cast expression yields an rvalue, but
                                           // its type is rvalue reference  (to Widget)

The conventional way to turn lvalues (such as var1) into rvalues is to use std::move on them, so var2 could be defined like this:

Widget var2 = std::move(var1);             // equivalent to above

I initially showed the code with static_cast only to make explicit that the type of the expression was an rvalue reference (Widget&&).

Named variables and parameters of rvalue reference type are lvalues. (You can take their addresses.) Consider again the Widget and Gadget templates from earlier:

template<typename T>
class Widget {
    ...
    Widget(Widget&& rhs);        // rhs’s type is rvalue reference,
    ...                          // but rhs itself is an lvalue
};

template<typename T1>
class Gadget {
    ...
    template <typename T2>
    Gadget(T2&& rhs);            // rhs is a universal reference whose type will
    ...                          // eventually become an rvalue reference or
};                               // an lvalue reference, but rhs itself is an lvalue

In Widget’s constructor, rhs is an rvalue reference, so we know it’s bound to an rvalue (i.e., an rvalue was passed to it), but rhs itself is an lvalue, so we have to convert it back to an rvalue if we want to take advantage of the rvalueness of what it’s bound to.  Our motivation for this is generally to use it as the source of a move operation, and that’s why the way to convert an lvalue to an rvalue is to use std::move.  Similarly, rhs in Gadget’s constructor is a universal reference, so it might be bound to an lvalue or to an rvalue, but regardless of what it’s bound to, rhs itself is an lvalue.  If it’s bound to an rvalue and we want to take advantage of the rvalueness of what it’s bound to, we have to convert rhs back into an rvalue. If it’s bound to an lvalue, of course, we don’t want to treat it like an rvalue.  This ambiguity regarding the lvalueness and rvalueness of what a universal reference is bound to is the motivation for std::forward:  to take a universal reference lvalue and convert it into an rvalue only if the expression it’s bound to is an rvalue.  The name of the function (“forward”) is an acknowledgment that our desire to perform such a conversion is virtually always to preserve the calling argument’s lvalueness or rvalueness when passing -- forwarding -- it to another function.

But std::move and std::forward are not the focus of this article.  The fact that “&&” in type declarations may or may not declare an rvalue reference is.  To avoid diluting that focus, I’ll refer you to the references in the Further Information section for information on std::move and std::forward.

Nitty Gritty Details

The true core of the issue is that some constructs in C++11 give rise to references to references, and references to references are not permitted in C++. If source code explicitly contains a reference to a reference, the code is invalid:

Widget w1;
...
Widget& & w2 = w1;               // error! No such thing as “reference to reference”

There are cases, however, where references to references arise as a result of type manipulations that take place during compilation, and in such cases, rejecting the code would be problematic. We know this from experience with the initial standard for C++, i.e., C++98/C++03.

During type deduction for a template parameter that is a universal reference, lvalues and rvalues of the same type are deduced to have slightly different types.  In particular, lvalues of type T are deduced to be of type T& (i.e., lvalue reference to T), while rvalues of type T are deduced to be simply of type T. (Note that while lvalues are deduced to be lvalue references, rvalues are not deduced to be rvalue references!) Consider what happens when a template function taking a universal reference is invoked with an rvalue and with an lvalue:

template<typename T>
void f(T&& param);

...

int x;

...

f(10);                           // invoke f on rvalue
f(x);                            // invoke f on lvalue

In the call to f with the rvalue 10, T is deduced to be int, and the instantiated f looks like this:

void f(int&& param);             // f instantiated from rvalue

That’s fine. In the call to f with the lvalue x, however, T is deduced to be int&, and f’s instantiation contains a reference to a reference:

void f(int& && param);           // initial instantiation of f with lvalue

Because of the reference-to-reference, this instantiated code is prima facie invalid, but the source code-- “f(x)” -- is completely reasonable.  To avoid rejecting it, C++11 performs “reference collapsing” when references to references arise in contexts such as template instantiation.

Because there are two kinds of references (lvalue references and rvalue references), there are four possible reference-reference combinations: lvalue reference to lvalue reference, lvalue reference to rvalue reference, rvalue reference to lvalue reference, and rvalue reference to rvalue reference.  There are only two reference-collapsing rules:

  • An rvalue reference to an rvalue reference becomes (“collapses into”) an rvalue reference.
  • All other references to references (i.e., all combinations involving an lvalue reference) collapse into an lvalue reference.

Applying these rules to the instantiation of f on an lvalue yields the following valid code, which is how the compiler treats the call:

void f(int& param);              // instantiation of f with lvalue after reference collapsing

This demonstrates the precise mechanism by which a universal reference can, after type deduction and reference collapsing, become an lvalue reference. The truth is that a universal reference is really just an rvalue reference in a reference-collapsing context.

Things get subtler when deducing the type for a variable that is itself a reference. In that case, the reference part of the type is ignored.  For example, given

int x;

...

int&& r1 = 10;                   // r1’s type is int&&

int& r2 = x;                     // r2’s type is int&

the type for both r1 and r2 is considered to be int in a call to the template f.  This reference-stripping behavior is independent of the rule that, during type deduction for universal references, lvalues are deduced to be of type T& and rvalues of type T, so given these calls,

f(r1);

f(r2);

the deduced type for both r1 and r2 is int&. Why? First the reference parts of r1’s and r2’s types are stripped off (yielding int in both cases), then, because each is an lvalue, each is treated as int& during type deduction for the universal reference parameter in the call to f.

Reference collapsing occurs, as I’ve noted, in “contexts such as template instantiation.” A second such context is the definition of auto variables.  Type deduction for auto variables that are universal references is essentially identical to type deduction for function template parameters that are universal references, so lvalues of type T are deduced to have type T&, and rvalues of type T are deduced to have type T.  Consider again this example from the beginning of this article:

Widget&& var1 = someWidget;      // var1 is of type Widget&& (no use of auto here)

auto&& var2 = var1;              // var2 is of type Widget& (see below)

var1 is of type Widget&&, but its reference-ness is ignored during type deduction in the initialization of var2; it’s considered to be of type Widget.  Because it’s an lvalue being used to initialize a universal reference (var2), its deduced type is Widget&.  Substituting Widget& for auto in the definition for var2 yields the following invalid code,

Widget& && var2 = var1;          // note reference-to-reference

which, after reference collapsing, becomes

Widget& var2 = var1;             // var2 is of type Widget&

A third reference-collapsing context is typedef formation and use. Given this class template,

template<typename T>
class Widget {
    typedef T& LvalueRefType;
    ...
};

and this use of the template,

Widget<int&> w;

the instantiated class would contain this (invalid) typedef:

typedef int& & LvalueRefType;

Reference-collapsing reduces it to this legitimate code:

typedef int& LvalueRefType;

If we then use this typedef in a context where references are applied to it, e.g.,

void f(Widget<int&>::LvalueRefType&& param);

the following invalid code is produced after expansion of the typedef,

void f(int& && param);

but reference-collapsing kicks in, so f’s ultimate declaration is this:

void f(int& param);

The final context in which reference-collapsing takes place is the use of decltype. As is the case with templates and auto, decltype performs type deduction on expressions that yield types that are either T or T&, and decltype then applies C++11’s reference-collapsing rules.  Alas, the type-deduction rules employed by decltype are not the same as those used during template or auto type deduction.  The details are too arcane for coverage here (the Further Information section provides pointers to, er, further information), but a noteworthy difference is that decltype, given a named variable of non-reference type, deduces the type T (i.e., a non-reference type), while under the same conditions, templates and auto deduce the type T&.  Another important difference is that decltype’s type deduction depends only on the decltype expression; the type of the initializing expression (if any) is ignored. Ergo:

Widget w1, w2;

auto&& v1 = w1;                  // v1 is an auto-based universal reference being
                                 // initialized with an lvalue, so v1 becomes an
                                 // lvalue reference referring to w1.

decltype(w1)&& v2 = w2;          // v2 is a decltype-based universal reference, and
                                 // decltype(w1) is Widget, so v2 becomes an rvalue reference.
                                 // w2 is an lvalue, and it’s not legal to initialize an
                                 // rvalue reference with an lvalue, so
                                 // this code does not compile.

Summary

In a type declaration, “&&” indicates either an rvalue reference or a universal reference -- a reference that may resolve to either an lvalue reference or an rvalue reference. Universal references always have the form T&& for some deduced type T.

Reference collapsing is the mechanism that leads to universal references (which are really just rvalue references in situations where reference-collapsing takes place) sometimes resolving to lvalue references and sometimes to rvalue references. It occurs in specified contexts where references to references may arise during compilation. Those contexts are template type deduction, auto type deduction, typedef formation and use, and decltype expressions.

Acknowledgments

Draft versions of this article were reviewed by Cassio Neri, Michal Mocny, Howard Hinnant, Andrei Alexandrescu, Stephan T. Lavavej, Roger Orr, Chris Oldwood, Jonathan Wakely, and Anthony Williams.  Their comments contributed to substantial improvements in the content of the article as well as in its presentation.

Notes

[1] I discuss rvalues and their counterpart, lvalues, later in this article. The restriction on lvalue references binding to rvalues is that such binding is permitted only when the lvalue reference is declared as a reference-to-const, i.e., a const T&.

[2] I’m ignoring the possibility of bounds violations. They yield undefined behavior.

[3] std::vector::push_back is overloaded. The version shown is the only one that interests us in this article.

Further Information

C++11, Wikipedia.

Overview of the New C++ (C++11), Scott Meyers, Artima Press, last updated January 2012.

C++ Rvalue References Explained, Thomas Becker, last updated September 2011.

decltype, Wikipedia.

“A Note About decltype,” Andrew Koenig, Dr. Dobb’s, 27 July 2011.

Boost 1.52.0 expected on Monday, November 5

Release 1.52.0 of the Boost C++ Libraries is expected on Monday, November 5.

These open-source libraries work well with the C++ Standard Library, and are usable across a broad spectrum of applications. The Boost license encourages both commercial and non-commercial use.

Releases 1.51.0 and 1.52.0 contain one new library (Boost.Context, by Oliver Kowalke) and numerous enhancements and bug fixes for existing libraries.

Here are some useful links for 1.51.0. We expect these to be updated on Monday.

Many thanks to the Boost release team:

    Beman Dawes
    Daniel James
    Eric Niebler
    Marshall Clow
    Rene Rivera
    Vladimir Prus

We very much appreciate their continued hard work.