Perfect forwarding in constructors (C++17)

Question

Consider the following code

struct A {
    A(int id) : id_ { id } {}

    A(const A& rhs) { std::cout << "cctor from " +
        std::to_string(rhs.id_) << std::endl; }
    A(A&& rhs) { std::cout << "mctor from " +
        std::to_string(rhs.id_) << std::endl; }

    int id_;
};

template<typename T>
struct B1 {
    constexpr B1(T&& x) noexcept : x_ { std::forward<T>(x) } {}

    T x_;
};

template<typename T>
struct B2 {
    constexpr B2(T&& x) noexcept;

    T x_;
};

template<typename T>
constexpr
B2<T>::B2(
    T&& x
) noexcept :
    x_ { std::forward<T>(x) } {
}

int
main(
) {
    A a { 1 };

    //B1 b11 { a }; // Not compiling
    B1 b12 { A { 2 } };

    B2 b21 { a };
    B2 b22 { A { 3 } };

    return 0;
 }

which yields

mctor from 2
mctor from 3

So it basically looks as if the externally defined constructor perfectly forwards the value category of its argument while the inline-defined constructor does not.

Is it that an externally defined constructor is handled like a function template (which perfectly forwards its arguments) or what's going on here?

Links to the appropriate section of the standard would be welcome.

I am using GCC 7.2.0.

I think that you have an imperfect understanding of what perfect forwarding means. Because your template argument is on the class, not the constructor, you are accepting r-value references, no forwarding references. — AndyG, Nov 28 '18 at 12:51
@AndyG: I think OP uses the wrong term, as there is the Template Argument Deduction with `T&&` (with `T` from class). — Jarod42, Nov 28 '18 at 12:56
To clarify OP's question: should `b21` be `B2`, or should it not compile ? — Jarod42, Nov 28 '18 at 12:58
[Possible duplicated](https://stackoverflow.com/questions/47986284/perfect-forwarding-with-class-template-argument-deduction) — felix, Nov 28 '18 at 13:12
For those looking for a way to implicitly deduce `b21` and `b22` as `B2` and `B2 `, respectively (as done in the code above), cf. [here](https://stackoverflow.com/questions/47591455/take-a-reference-if-lvalue-and-make-a-copy-if-rvalue-i-e-make-rvalue-persistent). — plexando, Nov 29 '18 at 14:55
Shouldn't there be another line of output ("cctor from 1") between those 2 lines? — Baruch, Sep 08 '20 at 19:34

score 11 · Accepted Answer · answered Nov 28 '18 at 12:53

11

It's a GCC bug. Forwarding references have a very clear cut definition:

[temp.deduct.call] (emphasis mine)

3 A forwarding reference is an rvalue reference to a cv-unqualified template parameter that does not represent a template parameter of a class template (during class template argument deduction ([over.match.class.deduct])). If P is a forwarding reference and the argument is an lvalue, the type “lvalue reference to A” is used in place of A for type deduction.

In both cases T names a template parameter of the enclosing class during CTAD, so it should not produce a forwarding reference either way. The c'tor being defined inline or outside the class definition has no bearing on this.

answered Nov 28 '18 at 12:53

StoryTeller - Unslander Monica

165,132
21
377
458

You wouldn't happen to have any idea if this has been reported to the project? – violet_white Nov 28 '18 at 18:11
1

@jaked122 - I gave the GCC bugzilla a quick search in an effort to complete the answer. And tried on the tip of the trunk that several online IDE's host (where it was reproduced). I'd guess it isn't a known bug, but I can't confirm – StoryTeller - Unslander Monica Nov 28 '18 at 18:14
Bug still present in latest snapshot (9.0.0 20181125 (experimental)). – plexando Nov 29 '18 at 11:21
@plexando - The snapshot is from 2018 11 25 (I.e. Nov 25). The report in the comment above is from yesterday. – StoryTeller - Unslander Monica Nov 29 '18 at 11:25

score 8 · Answer 2 · answered Nov 28 '18 at 13:11

It looks that GCC incorrectly treats T&& in an auto-generated deduction guide as a forwarding reference:

template <typename T>
B2(T&& x) -> B2<T>;

In this case T&& is a non-forwarding r-value reference, because it's a class parameter. Instead, GCC incorrectly deduces T=A& parameter type and B2<T>=B2<A&> class type, which collapses the reference type in the constructor, allowing the code to compile with an lvalue constructor argument:

constexpr B2(A& x) noexcept;

Class template argument deduction makes no distinction between inline and and out-of-line definitions. In this particular case, B2 b21 { a }; should fail.

Perfect forwarding in constructors (C++17)

2 Answers2