Why can't the compiler find the assignment operator?

Question

template <typename T>
class MyPointer
{public:


    template <typename U>
    void operator=(MyPointer<U>&& other)
    {
      
    }
    char* get() const { return pointer; }
private:
    char* pointer;
};

int main()
{
    struct B {};
    struct D : B{};   

    MyPointer<B> my_pointer_b;
    MyPointer<D> my_pointer_d;

    my_pointer_b = my_pointer_d;


}

The error I get:

binary '=': no operator found which takes a right-hand operand of type 'MyPointermain::D' (or there is no acceptable conversion)

The compiler instantiates the assignment operator for the particular type that I use, so even if it deleted the default one the instantiated one should be there.

@Yksisarvinen No it doesn't && is a universal reference, not an r-value. It takes both — Zebrafish
– Zebrafish, Commented Jul 6, 2023 at 12:57
@Yksisarvinen ohhhhh, that's not a universal reference, i would have been if it was U type — Zebrafish
– Zebrafish, Commented Jul 6, 2023 at 12:58

463035818_is_not_an_ai · Accepted Answer · 2023-07-06 13:00:21Z

Perhaps the error with gcc helps to shed more light on this:

<source>:24:20: error: cannot bind rvalue reference of type 'MyPointer<main()::D>&&' to lvalue of type 'MyPointer<main()::D>'
   24 |     my_pointer_b = my_pointer_d;
      |                    ^~~~~~~~~~~~

Your MyPointer<U>&& is not a forwarding reference. Its a rvalue reference.

From cppreference:

Forwarding references are a special kind of references that preserve the value category of a function argument, making it possible to forward it by means of std::forward. Forwarding references are either:

function parameter of a function template declared as rvalue reference to cv-unqualified type template parameter of that same function template:

[... auto&& ...]

This is a forwarding reference

template <typename T> void foo(T&&);

This one is not

template <typename T> void bar(X<T>&&);

Nelfeal · Accepted Answer · 2023-07-06 13:12:26Z

template <typename U>
void operator=(MyPointer<U>&& other)

In this, MyPointer<U>&& is not a forwarding reference. It's an rvalue reference to some MyPointer<U>, where U is deduced from the argument.

As a result, you cannot call this function with an lvalue.

If you want to use a forwarding reference but constrain it to a MyPointer instance, then you can do something like this:

// forward declaration
template <typename T>
class MyPointer;

template <typename T>
struct IsMyPointerInstance : std::false_type {};

template <typename T>
struct IsMyPointerInstance<MyPointer<T>> : std::true_type {};

template <typename T>
concept MyPointerInstance = IsMyPointerInstance<std::remove_cvref_t<T>>::value;

template <typename T>
class MyPointer {
public:
    template <typename U> requires MyPointerInstance<U>
    void operator=(U&& other) {
        // ...
    }

Demo

(or use SFINAE if you can't use concepts)

Collectives™ on Stack Overflow

Why can't the compiler find the assignment operator?

2 Answers 2

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related