Can an rvalue of a specific class type be automatically cast to an lvalue of itself?

Question

In C++, a function with signature void f(A& a) (non-template) only binds to a lvalue.

Is it possible for an rvalue to automatically cast itself to an lvalue?

This is what I tried:

#include <cassert>
#include <utility>

struct A {
    operator A&() && {
        return *this;
    }
    void mutate() {...}
};

This produces a compiler warning, "converting 'A' to a reference to the same type will never use a type conversion". But at least the operator is compiled and works, except that it needs to be explicitly called with the full .operator A&() syntax.

void f(A& a) { a.mutate(); }

A make_A() { return A{}; }

int main() {
    A a;

    f(a);  // ok
    f(make_A().operator A&());  // ok
    f(make_A());  // does not compile, implicit conversion to A& doesn't work
    f(std::move(a));  // does not compile
}

https://godbolt.org/z/oKM8n5z1E

A similar question was asked before Rvalue to lvalue conversion? that shows how to do this. In my case, I want to enable this, but only for a specific class.

Is there a trick or workaround to achieve this?

auto as_lvalue(std::string&& s) -> std::string& { return s; } would spoof the rvalue as being an lvalue. Kind of the opposite of std::move. — Eljay
– Eljay, Commented Aug 10 at 22:59
The solution to the current duplicate target is the same solution for this question. The fact that you want to implement the solution for a specific class doesn't seem to be a sufficiently different question. — cigien
– cigien, Commented Aug 11 at 8:44
Even if the solution is nominally the same, the problem is different and could have had a different solution, different in generality. The other question is hard to find; it doesn't even have a verb in the title. — alfC
– alfC, Commented Aug 12 at 6:40
@alfC Yeah, that's fair, it's a reasonably different question that happens to have the same answer. BTW, the argument that the other question is hard to find is a bad argument, since that's literally the purpose of duplicate closures; having multiple ways of asking the same question, but all of them pointing to one canonical :) — cigien
– cigien, Commented Aug 18 at 15:42

cpplearner · Accepted Answer · 2025-08-10 23:01:29Z

9

No. This can't be done automatically.

Some libraries (including the standard library) use an internal helper function when they need such a conversion:

template<class T>
constexpr T& as_lvalue(T&& t) { return static_cast<T&>(t); }

answered Aug 10 at 23:01

cpplearner

19.2k3 gold badges61 silver badges92 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

alfC Aug 11 at 0:47

Ok, good to know (and sad). I guess that could be just the same as T& as_lvalue(T&& t) { return t; }.

HolyBlackCat Aug 11 at 6:36

The simplified implicit move in return in C++23 makes this no longer compiler.

alfC Aug 11 at 6:42

@HolyBlackCat, which version doesn't compile in C++23? why exactly?

HolyBlackCat Aug 11 at 6:43

The one you suggested: gcc.godbolt.org/z/o176YbW6P

Aleksandr Medvedev · Accepted Answer · 2025-08-11 07:47:26Z

3

Technically you can do that with help of virtual dispatch, but I wouldn't say you can benefit from that:

#include <iostream>

struct Derived;

struct Base {
    virtual operator Derived&() && = 0;
};

struct Derived : Base {
    operator Derived&() && override {
        return *this;
    }
};

void Foo(Derived&) {
    std::cout << "Converted";
}

int main() {
    Foo(static_cast<Base&&>(Derived{}));
}

Without it, such a conversion is directly prohibited (both explicit and implicit) by the class.conv.fct/note-1 (emphasis mine):

A conversion function is never invoked for implicit or explicit conversions of an object to the same object type (or a reference to it), to a base class of that type (or a reference to it), or to cv void. Even though never directly called to perform a conversion, such conversion functions can be declared and can potentially be reached through a call to a virtual conversion function in a base class.

The earlier draft (n4950) also gives the following rationale in class.conv.fct/footnote-97:

These conversions are considered as standard conversions for the purposes of overload resolution ([over.best.ics], [over.ics.ref]) and therefore initialization ([dcl.init]) and explicit casts ([expr.static.cast]).

edited Aug 11 at 7:47

answered Aug 11 at 0:00

Aleksandr Medvedev

10.3k3 gold badges25 silver badges66 bronze badges

2 Comments

alfC Aug 11 at 0:34

Interesting technique. Also, the function doesn't need to be virtual for it to work: godbolt.org/z/4r6YjaYbb. But yeah, it is not helpful at the end because it is still explicit (needs a cast to the base class, which I might as well replace with an explicit function).

alfC Aug 11 at 0:36

I wonder why the language will forbid this. I would find it helpful for types that represent "reference" and at the point of on-the-fly creation, they are accidentally rvalues, but they are semantically just l-value reference-like.

Collectives™ on Stack Overflow

Can an rvalue of a specific class type be automatically cast to an lvalue of itself?

2 Answers 2

4 Comments

2 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

4 Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related