包装为完美的转发构造函数

Question

I want to make a wrapper for a constructor of a class B.

Since some part of the class B is replaceable, I group each implementation of those parts into several class A.

I use perfect forwarding to provide a default implementation of A for constructing a B.

The problem is the wrapper doesn't work. How to fix this?

Thanks.

The following is also at https://godbolt.org/g/AWwtbf

template<typename T>
class A {
public:
    A() { _x = 2; }
    int _x;
};

template<typename T, typename C=A<T> >
class B {
public:
    explicit B(T x, C&& a = A<T>())
            : _x(x), _a(a) {
    }
    T _x;
    A<T>& _a;
};

template<typename T, typename C=A<T> >
B<T, A<T>> make_b(T x, C&& c = A<T>()) {
    return B<int, A<int>>(x, c);
};

int main() {
    B<int, A<int>> b1(1);  // this works.
    auto b2 = make_b(1);  // this doesn't
}

Error:

error: cannot bind rvalue reference of type 'A<int>&&' to lvalue of type 'A<int>'

     return B<int, A<int>>(x, c);

Answer 1

How to perfect-forward stuff?

1. Make the type of the argument a template parameter.
2. Accept the argument by rvalue-reference ( && ).
3. std::forward the argument.

You got nr. 1 and 2 but forgot nr. 3:

template<typename T, typename C=A<T> >
B<T, A<T>> make_b(T x, C&& c = A<T>()) {
    return B<T, A<int>>(x, std::forward<C>(c));
};

How to avoid a dangling reference?

This code creates a dangling reference, ie a reference to an object that's already gone :

    explicit B(T x, C&& a = A<T>())
            : _x(x), _a(a) {
    }
    T _x;
    A<T>& _a;

Consider what happens here: a temporary A is created, the rvalue reference a is being used in an lvalue expression ( a ) so it turns into an lvalue reference and A& _a subsequently happily binds to it. By the time the full-expression is finished (at the first ; ) the temporary A instance is destroyed and A& _a refers to a non-existent object. If _a is used after that point, the behavior is undefined.

Avoid references as data members until you understand value categories , object lifetime and reference collapsing rules.

Just store A by value:

    explicit B(T x, C&& a = A<T>())
            : _x(x), _a(std::move(a)) {
    }
    T _x;
    A<T> _a;

Or instantiate A outside B and pass it as an lvalue reference:

    explicit B(T x, C& a) : _x(x), _a(a) {}
    C& _a;