What can be done to prevent misleading assigment to returned value?

After many years of using C++ I realized a quirk in the syntax when using custom classes. Despite being the correct language behavior it allows to create very misleading interfaces.

Example here:

class complex_arg {
    double r_;
    double phi_;
 public:
    std::complex<double> value() const {return r_*exp(phi_*std::complex<double>{0, 1});}
};

int main() {
    complex_arg ca;
    ca.value() = std::complex<double>(1000., 0.);  // accepted by the compiler !?
    assert( ca.value() != std::complex<double>(1000., 0.) ); // what !?
}

https://godbolt.org/z/Y5Pcjsc8d

What can be done to the class definition to prevent this behavior? (Or at the least flag the user of the clas that the 3rd line is not really doing any assignment.)

I see only one way out, but it requires modifying the class and it doesn't scale well (to large classes that can be moved).

    const std::complex<double> value() const;

I also tried [[nodiscard]] value() but it didn't help.

As a last resort, maybe something can be done to the returned type std::complex<double> ? (that is, assuming one is in control of that class)

Note that I understand that sometimes one might need to do (optimized) assign to a newly obtained value and passe it to yet another function f( ca.value() = bla ). I am not questioning this usage per se (although it is quite confusing as well); I have the problem mostly with ca.value() = bla; as a standalone statement that doesn't do what it looks.

Ordinarily we can call a member function on an object regardless of whether that object's value category is an lvalue or rvalue.

What can be done to the class definition to prevent this behavior?

Prior to modern C++ there was no way prevent this usage. But since C++11 we can ref-qualify a member function to do what you ask as shown below.

From member functions:

During overload resolution, non-static member function with a cv-qualifier sequence of class X is treated as follows:

• no ref-qualifier: the implicit object parameter has type lvalue reference to cv-qualified X and is additionally allowed to bind rvalue implied object argument

• lvalue ref-qualifier: the implicit object parameter has type lvalue reference to cv-qualified X

• rvalue ref-qualifier: the implicit object parameter has type rvalue reference to cv-qualified X

This allows us to do what you ask for a custom managed class. In particular, we can & qualify the copy assignment operator.

struct C
{
    C(int)
    {
      std::cout<<"converting ctor called"<<std::endl;
    }
    C(){
        std::cout<<"default ctor called"<<std::endl;
    }
    C(const C&)
    {
     std::cout<<"copy ctor called"<<std::endl;
    }
//-------------------------v------>added this ref-qualifier
    C& operator=(const C&) &
    {
    std::cout<<"copy assignment operator called"<<std::endl;;
    return *this;
    }

};
C func()
{
    C temp;
    return temp;
}

int main()
{
//---------v---------> won't work because assignment operator is & qualified
    func() = 4;
}