Why call to overloaded overridden function with universal or r-value reference is ambiguous?

Question

I have a problem related to reference forwarding, to which I am only slightly familiar with. Before stating my question, I want to say that I've read a few pages related to this language feature and they kind of confused me rather than shedding light into my problem. The consulted references are: [1-5], some of which I find contradictory or don't fully understand. Aware of the fact that this question could be considered a duplicate, I am posting it anyways because I couldn't find a case that would combine these three factors:

Overloaded functions with r-value references.
Templated classes (not functions).
Override of overloaded functions where the parent class' function is called in the overrides.

Problem scenario

I have two classes that I use to represent a variable of a model. The generic one is MState<T> and I template it because I want it to wrap any possible type inside. It's more like a wrapper to a type that I have created for a purpose which is irrelevant to this question. Then, I have MOutput<T>, which essentially extends MState<T> and represents an externally visible variable of a user-defined model.

They both have a member function called setValue which allows to, well... set their value. I know it would be nices to implement operator semantics, but for now I'm dealing with this:

template <class T>
class MState
{
public:
    virtual void setValue(T value) {      // -- (A)
        m_state = value;
        // (... more things.)
    }
    virtual void setValue(T&& value) {    // -- (B)
        m_state = value;
        // (... more things.)
    }
    T getValue(void) { return m_state; }
protected:
    T m_state;
};

template <class T>
class MOutput : public MState<T>
{
public:
    void setValue(T value) override {                     // -- (C)
        MState<T>::setValue(std::forward<T>(value));
        // (... even more things.)
    }
    void setValue(T&& value) override {                   // -- (D)
        MState<T>::setValue(std::forward<T>(value));
        // (... even more things.)
    }
};

I think I need (A) to allow for l-values to be valid arguments in calls to MState::setValue. Actually, if I remove it the compiler complains that it cannot convert an l-value to an r-value reference (which I understood with [4].) However, I want to avoid unnecessary resource allocations and copies, especially when dealing with temporaries (e.g. ms.setValue(MyClass()).) Hence (B).

Likewise, (C) is necessary because I need MOutput's to do a few things more, in addition to the ones MState implements. For the same motivation above, I also want (D).

The use of std::forward<T>(value) in (C) and (D) is motivated by [3].

Question

When I try to compile my code, GCC complains about the overloaded function signature to be ambiguous in both classes and a number of cases. I think I don't understand why, or how to solve the issue. Is T&& here a universal reference? If so, shouldn't these accept any kind of argument type?

Use cases

GCC fails to compile the line MState<T>::setValue(std::forward<T>(value)); of both (C) and (D). If I comment them out, I get the same ambiguity error in these cases:

bool function(int a) { return a >= 1; }
MOutput<bool> vo0, vo1, vo2;
vo1.setValue(true);                                // Error.
vo2.setValue(false);                               // Error.
vo0.setValue(!(vo1.getValue() & vo2.getValue()));  // Error.

MOutput<int> vo3;
vo3.setValue(432);                                 // Error.

Consulted references

You should be using `std::forward` when dealing with templates. And let it do the proper conversion. — Ron, Jun 22 '18 at 15:02
FWIW, `T&& value` is not a universal reference since `T`'s type is known (it is the class template type). `T&& value` is only a universal reference when `T` is a template parameter for the function itself. — NathanOliver, Jun 22 '18 at 15:03
To accept an lvalue, use `const T&`. To accept an rvalue, use `const T&`. One function. Problem solved. — Pete Becker, Jun 22 '18 at 15:07
What if I want to allow temporaries (and want to avoid unnecessary resource allocations and copies) @PeteBecker? — Carles Araguz, Jun 22 '18 at 15:13
I may have missed your point. Are you looking to **move from** rvalues? If so, two overloads: one `const T&` and one `T&&`. — Pete Becker, Jun 22 '18 at 16:22

score 1 · Answer 1 · answered Jun 22 '18 at 16:40

I believe that in this case, it can't tell whether it should make a copy of T, or pass it in via an rvalue reference, thus the ambiguity. Try taking a const reference to T for the first function.

Also std::forward is intended for when you're doing universal reference (rvalue references in a deduced context), I don't believe it applies here.

score 1 · Accepted Answer · answered Jun 22 '18 at 17:03

I would simply have simple void setValue(const T& value) (even more when your getter does copy).

But if you want both l-value reference, and r-value reference, it would be something like:

template <class T>
class MState
{
public:
    virtual void setValue(const T& value) {
        m_state = value;
        MoreStuff()
    }
    virtual void setValue(T&& value) {
        m_state = std::move(value);
        MoreStuff()
    }
    const T& getValue() const { return m_state; }
private:
    void MoreStuff();
protected:
    T m_state;
};

template <class T>
class MOutput : public MState<T>
{
public:
    void setValue(const T& value) override {
        MState<T>::setValue(value);
        MoreThings();
    }
    void setValue(T&& value) override {
        MState<T>::setValue(std::move(value));
        MoreThings();
    }
private:
    void MoreThings();
};

Is T&& here a universal reference?

As state, in comment, no it isn't, T is fixed by the class.

Why call to overloaded overridden function with universal or r-value reference is ambiguous?

Problem scenario

Question

Use cases

Consulted references

2 Answers2