# What does T&& (double ampersand) mean in C++11?

I've been looking into some of the new features of C++11 and one I've noticed is the double ampersand in declaring variables, like `T&& var`.

For a start, what is this beast called? I wish Google would allow us to search for punctuation like this.

What exactly does it mean?

At first glance, it appears to be a double reference (like the C-style double pointers `T** var`), but I'm having a hard time thinking of a use case for that.

• I've added this to the c++-faq, since I'm sure it'll come up more in the future. – GManNickG Mar 30 '11 at 3:50
• related question about move semantics – fredoverflow Mar 30 '11 at 6:56
• You can search for this using google, you only have to wrap your phrase in quotes: google.com/#q="T%26%26" now has your question as the first hit. `:)` – sbi Jun 22 '11 at 7:46
• There is a very good, easy to understand response to a similar question here stackoverflow.com/questions/7153991/… – Daniel Aug 23 '11 at 13:38
• I got three stackoverflow questions at the top searching in Google for "c++ two ampersands parameter" and yours was the first one. So you don't even need to use punctuation for this if you can spell out "two ampersands parameter". – sergiol Aug 14 '15 at 7:28

It declares an rvalue reference (standards proposal doc).

Here's an introduction to rvalue references.

Here's a fantastic in-depth look at rvalue references by one of Microsoft's standard library developers.

CAUTION: the linked article on MSDN ("Rvalue References: C++0x Features in VC10, Part 2") is a very clear introduction to Rvalue references, but makes statements about Rvalue references that were once true in the draft C++11 standard, but are not true for the final one! Specifically, it says at various points that rvalue references can bind to lvalues, which was once true, but was changed.(e.g. int x; int &&rrx = x; no longer compiles in GCC) – drewbarbs Jul 13 '14 at 16:12

The biggest difference between a C++03 reference (now called an lvalue reference in C++11) is that it can bind to an rvalue like a temporary without having to be const. Thus, this syntax is now legal:

``````T&& r = T();
``````

rvalue references primarily provide for the following:

Move semantics. A move constructor and move assignment operator can now be defined that takes an rvalue reference instead of the usual const-lvalue reference. A move functions like a copy, except it is not obliged to keep the source unchanged; in fact, it usually modifies the source such that it no longer owns the moved resources. This is great for eliminating extraneous copies, especially in standard library implementations.

For example, a copy constructor might look like this:

``````foo(foo const& other)
{
this->length = other.length;
this->ptr = new int[other.length];
copy(other.ptr, other.ptr + other.length, this->ptr);
}
``````

If this constructor was passed a temporary, the copy would be unnecessary because we know the temporary will just be destroyed; why not make use of the resources the temporary already allocated? In C++03, there's no way to prevent the copy as we cannot determine we were passed a temporary. In C++11, we can overload a move constructor:

``````foo(foo&& other)
{
this->length = other.length;
this->ptr = other.ptr;
other.length = 0;
other.ptr = nullptr;
}
``````

Notice the big difference here: the move constructor actually modifies its argument. This would effectively "move" the temporary into the object being constructed, thereby eliminating the unnecessary copy.

The move constructor would be used for temporaries and for non-const lvalue references that are explicitly converted to rvalue references using the `std::move` function (it just performs the conversion). The following code both invoke the move constructor for `f1` and `f2`:

``````foo f1((foo())); // Move a temporary into f1; temporary becomes "empty"
foo f2 = std::move(f1); // Move f1 into f2; f1 is now "empty"
``````

Perfect forwarding. rvalue references allow us to properly forward arguments for templated functions. Take for example this factory function:

``````template <typename T, typename A1>
std::unique_ptr<T> factory(A1& a1)
{
return std::unique_ptr<T>(new T(a1));
}
``````

If we called `factory<foo>(5)`, the argument will be deduced to be `int&`, which will not bind to a literal 5, even if `foo`'s constructor takes an `int`. Well, we could instead use `A1 const&`, but what if `foo` takes the constructor argument by non-const reference? To make a truly generic factory function, we would have to overload factory on `A1&` and on `A1 const&`. That might be fine if factory takes 1 parameter type, but each additional parameter type would multiply the necessary overload set by 2. That's very quickly unmaintainable.

rvalue references fix this problem by allowing the standard library to define a `std::forward` function that can properly forward lvalue/rvalue references. For more information about how `std::forward` works, see this excellent answer.

This enables us to define the factory function like this:

``````template <typename T, typename A1>
std::unique_ptr<T> factory(A1&& a1)
{
return std::unique_ptr<T>(new T(std::forward<A1>(a1)));
}
``````

Now the argument's rvalue/lvalue-ness is preserved when passed to `T`'s constructor. That means that if factory is called with an rvalue, `T`'s constructor is called with an rvalue. If factory is called with an lvalue, `T`'s constructor is called with an lvalue. The improved factory function works because of one special rule:

When the function parameter type is of the form `T&&` where `T` is a template parameter, and the function argument is an lvalue of type `A`, the type `A&` is used for template argument deduction.

Thus, we can use factory like so:

``````auto p1 = factory<foo>(foo()); // calls foo(foo&&)
auto p2 = factory<foo>(*p1);   // calls foo(foo const&)
``````

Important rvalue reference properties:

• For overload resolution, lvalues prefer binding to lvalue references and rvalues prefer binding to rvalue references. Hence why temporaries prefer invoking a move constructor / move assignment operator over a copy constructor / assignment operator.
• rvalue references will implicitly bind to rvalues and to temporaries that are the result of an implicit conversion. i.e. `float f = 0f; int&& i = f;` is well formed because float is implicitly convertible to int; the reference would be to a temporary that is the result of the conversion.
• Named rvalue references are lvalues. Unnamed rvalue references are rvalues. This is important to understand why the `std::move` call is necessary in: `foo&& r = foo(); foo f = std::move(r);`
• +1 for `Named rvalue references are lvalues. Unnamed rvalue references are rvalues.`; without knowing this I've struggled to understand why people do a `T &&t; std::move(t);` for a long time in move ctors, and the like. – legends2k May 30 '13 at 12:32
• @MaximYegorushkin: In that example, r is binding to a pure rvalue (temporary) and therefore the temporary should have its lifetime scope extended, no? – Peter Huene Jul 31 '13 at 19:26
• @PeterHuene I take that back, an r-value reference does extend the lifetime of a temporary. – Maxim Egorushkin Jul 31 '13 at 21:30
• CAUTION: the linked article on MSDN ("Rvalue References: C++0x Features in VC10, Part 2") is a very clear introduction to Rvalue references, but makes statements about Rvalue references that were once true in the draft C++11 standard, but are not true for the final one! Specifically, it says at various points that rvalue references can bind to lvalues, which was once true, but was changed.(e.g. `int x; int &&rrx = x;` no longer compiles in GCC) – drewbarbs Jul 13 '14 at 16:12
• @PeterHuene In the above example, isn't `typename identity<T>::type& a` equivalent to `T&` ? – ibp73 Sep 7 '14 at 14:50

It denotes an rvalue reference. Rvalue references will only bind to temporary objects, unless explicitly generated otherwise. They are used to make objects much more efficient under certain circumstances, and to provide a facility known as perfect forwarding, which greatly simplifies template code.

In C++03, you can't distinguish between a copy of a non-mutable lvalue and an rvalue.

``````std::string s;
std::string another(s);           // calls std::string(const std::string&);
std::string more(std::string(s)); // calls std::string(const std::string&);
``````

In C++0x, this is not the case.

``````std::string s;
std::string another(s);           // calls std::string(const std::string&);
std::string more(std::string(s)); // calls std::string(std::string&&);
``````

Consider the implementation behind these constructors. In the first case, the string has to perform a copy to retain value semantics, which involves a new heap allocation. However, in the second case, we know in advance that the object which was passed in to our constructor is immediately due for destruction, and it doesn't have to remain untouched. We can effectively just swap the internal pointers and not perform any copying at all in this scenario, which is substantially more efficient. Move semantics benefit any class which has expensive or prohibited copying of internally referenced resources. Consider the case of `std::unique_ptr`- now that our class can distinguish between temporaries and non-temporaries, we can make the move semantics work correctly so that the `unique_ptr` cannot be copied but can be moved, which means that `std::unique_ptr` can be legally stored in Standard containers, sorted, etc, whereas C++03's `std::auto_ptr` cannot.

Now we consider the other use of rvalue references- perfect forwarding. Consider the question of binding a reference to a reference.

``````std::string s;
std::string& ref = s;
(std::string&)& anotherref = ref; // usually expressed via template
``````

Can't recall what C++03 says about this, but in C++0x, the resultant type when dealing with rvalue references is critical. An rvalue reference to a type T, where T is a reference type, becomes a reference of type T.

``````(std::string&)&& ref // ref is std::string&
(const std::string&)&& ref // ref is const std::string&
(std::string&&)&& ref // ref is std::string&&
(const std::string&&)&& ref // ref is const std::string&&
``````

Consider the simplest template function- min and max. In C++03 you have to overload for all four combinations of const and non-const manually. In C++0x it's just one overload. Combined with variadic templates, this enables perfect forwarding.

``````template<typename A, typename B> auto min(A&& aref, B&& bref) {
// for example, if you pass a const std::string& as first argument,
// then A becomes const std::string& and by extension, aref becomes
// const std::string&, completely maintaining it's type information.
if (std::forward<A>(aref) < std::forward<B>(bref))
return std::forward<A>(aref);
else
return std::forward<B>(bref);
}
``````

I left off the return type deduction, because I can't recall how it's done offhand, but that min can accept any combination of lvalues, rvalues, const lvalues.

• why you used `std::forward<A>(aref) < std::forward<B>(bref)`? and I dont think this definition will be correct when you try forward `int&` and `float&`. Better drop one type form template. – Yankes Jul 4 '13 at 13:24

The term for `T&&` when used with type deduction (such as for perfect forwarding) is known colloquially as a forwarding reference. The term "universal reference" was coined by Scott Meyers in this article, but was later changed.

That is because it may be either r-value or l-value.

Examples are:

``````// template
template<class T> foo(T&& t) { ... }

// auto
auto&& t = ...;

// typedef
typedef ... T;
T&& t = ...;

// decltype
decltype(...)&& t = ...;
``````

More discussion can be found in the answer for: Syntax for universal references

An rvalue reference is a type that behaves much like the ordinary reference X&, with several exceptions. The most important one is that when it comes to function overload resolution, lvalues prefer old-style lvalue references, whereas rvalues prefer the new rvalue references:

``````void foo(X& x);  // lvalue reference overload
void foo(X&& x); // rvalue reference overload

X x;
X foobar();

foo(x);        // argument is lvalue: calls foo(X&)
foo(foobar()); // argument is rvalue: calls foo(X&&)
``````

So what is an rvalue? Anything that is not an lvalue. An lvalue being an expression that refers to a memory location and allows us to take the address of that memory location via the & operator.

It is almost easier to understand first what rvalues accomplish with an example:

`````` #include <cstring>
class Sample {
int *ptr; // large block of memory
int size;
public:
Sample(int sz=0) : ptr{sz != 0 ? new int[sz] : nullptr}, size{sz}
{
if (ptr != nullptr) memset(ptr, 0, sz);
}
// copy constructor that takes lvalue
Sample(const Sample& s) : ptr{s.size != 0 ? new int[s.size] :\
nullptr}, size{s.size}
{
if (ptr != nullptr) memcpy(ptr, s.ptr, s.size);
std::cout << "copy constructor called on lvalue\n";
}

// move constructor that take rvalue
Sample(Sample&& s)
{  // steal s's resources
ptr = s.ptr;
size = s.size;
s.ptr = nullptr; // destructive write
s.size = 0;
cout << "Move constructor called on rvalue." << std::endl;
}
// normal copy assignment operator taking lvalue
Sample& operator=(const Sample& s)
{
if(this != &s) {
delete [] ptr; // free current pointer
size = s.size;

if (size != 0) {
ptr = new int[s.size];
memcpy(ptr, s.ptr, s.size);
} else
ptr = nullptr;
}
cout << "Copy Assignment called on lvalue." << std::endl;
return *this;
}
// overloaded move assignment operator taking rvalue
Sample& operator=(Sample&& lhs)
{
if(this != &s) {
delete [] ptr; //don't let ptr be orphaned
ptr = lhs.ptr;   //but now "steal" lhs, don't clone it.
size = lhs.size;
lhs.ptr = nullptr; // lhs's new "stolen" state
lhs.size = 0;
}
cout << "Move Assignment called on rvalue" << std::endl;
return *this;
}
//...snip
};
``````

The constructor and assignment operators have been overloaded with versions that take rvalue references. Rvalue references allow a function to branch at compile time (via overload resolution) on the condition "Am I being called on an lvalue or an rvalue?". This allowed us to create more efficient constructor and assignment operators above that move resources rather copy them.

The compiler automatically branches at compile time (depending on the whether it is being invoked for an lvalue or an rvalue) choosing whether the move constructor or move assignment operator should be called.

Summing up: rvalue references allow move semantics (and perfect forwarding, discussed in the article link below).

One practical easy-to-understand example is the class template std::unique_ptr. Since a unique_ptr maintains exclusive ownership of its underlying raw pointer, unique_ptr's can't be copied. That would violate their invariant of exclusive ownership. So they do not have copy constructors. But they do have move constructors:

``````template<class T> class unique_ptr {
//...snip
unique_ptr(unique_ptr&& __u) noexcept; // move constructor
};

std::unique_ptr<int[] pt1{new int};
std::unique_ptr<int[]> ptr2{ptr1};// compile error: no copy ctor.

// So we must first cast ptr1 to an rvalue
std::unique_ptr<int[]> ptr2{std::move(ptr1)};

std::unique_ptr<int[]> TakeOwnershipAndAlter(std::unique_ptr<int[]> param,\
int size)
{
for (auto i = 0; i < size; ++i) {
param[i] += 10;
}
return param; // implicitly calls unique_ptr(unique_ptr&&)
}

// Now use function
unique_ptr<int[]> ptr{new int};

// first cast ptr from lvalue to rvalue
unique_ptr<int[]> new_owner = TakeOwnershipAndAlter(\
static_cast<unique_ptr<int[]>&&>(ptr), 10);

cout << "output:\n";

for(auto i = 0; i< 10; ++i) {
cout << new_owner[i] << ", ";
}

output:
10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
``````

`static_cast<unique_ptr<int[]>&&>(ptr)` is usually done using std::move

``````// first cast ptr from lvalue to rvalue
unique_ptr<int[]> new_owner = TakeOwnershipAndAlter(std::move(ptr),0);
``````

An excellent article explaining all this and more (like how rvalues allow perfect forwarding and what that means) with lots of good examples is Thomas Becker's C++ Rvalue References Explained. This post relied heavily on his article.

A shorter introduction is A Brief Introduction to Rvalue References by Stroutrup, et. al

• Isn't is so that the copy constructor `Sample(const Sample& s)` needs also to copy the contents ? The same question for the 'copy assignment operator'. – K.Karamazen Dec 28 '19 at 17:08
• Yes, you are right. I failed to copy the memory. The copy constructor and copy assignment operator should both do memcpy(ptr, s.ptr, size) after testing that size != 0. And the default constructor should do memset(ptr,0, size) if size != 0. – kurt krueckeberg Dec 29 '19 at 22:38
• Okay, thanks. Thus this comment and the previous two comments can be removed because the problem has also been rectified in the answer. – K.Karamazen Dec 31 '19 at 10:12
{"ft_lang_label":"__label__en","ft_lang_prob":0.8148515,"math_prob":0.88543,"size":5302,"snap":"2020-45-2020-50","text_gpt3_token_len":1223,"char_repetition_ratio":0.1604379,"word_repetition_ratio":0.021301774,"special_character_ratio":0.23519427,"punctuation_ratio":0.14117648,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.95990974,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2020-10-31T11:12:53Z\",\"WARC-Record-ID\":\"<urn:uuid:a4deeae3-37fd-43a7-bf27-ab19701c033f>\",\"Content-Length\":\"209629\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:97caca09-0052-43aa-926b-cf7426815ffd>\",\"WARC-Concurrent-To\":\"<urn:uuid:82e40f3c-81c6-464e-a844-07bb26a2112b>\",\"WARC-IP-Address\":\"151.101.1.69\",\"WARC-Target-URI\":\"https://stackoverflow.com/questions/5481539/what-does-t-double-ampersand-mean-in-c11\",\"WARC-Payload-Digest\":\"sha1:DJEQVVYM52GBMRW464FZUB5TKDGUDNYR\",\"WARC-Block-Digest\":\"sha1:NZQ6XCY34TSHOLE4VDT6ZHMJS7UFBSJN\",\"WARC-Identified-Payload-Type\":\"text/html\",\"warc_filename\":\"/cc_download/warc_2020/CC-MAIN-2020-45/CC-MAIN-2020-45_segments_1603107917390.91_warc_CC-MAIN-20201031092246-20201031122246-00659.warc.gz\"}"}