C ++：转换运算符重载和引用

Question

C++ allows for overloading type casts by creating an operator T() where T is the type we want to cast to.

Now, how does this feature play together with references? For example:

struct Y{ int i; };

struct X{
    Y y;

    operator Y() const { return y; }
};

Here, we can cast an X to Y which will simply return the contained Y . But what if we want to make a cast to an Y reference. For example, C++ allows us to do this:

struct X{
    Y y;

    operator Y&(){ return y; }
    operator const Y&() const { return y; }
};

Now, we can cast an X to a Y reference or a const reference (which also works for a const X ).

Is there any difference in the semantics of the first and the second example? What is the best way if I want to allow casting to a reference?

I could imagine that even if I write operator T() without any & , C++ might allow that the cast returns a result by reference (ie, it might somehow add implicit operator T&() methods when I specify operator T() ).

For example, I want the following code to work:

int main(){
    X x;
    Y& y = x; // y now references the y inside x
    y.i = 5;
    std::cout << x.y.i << std::endl; // Should print 5 now
}

What is the most simple way to achieve this?

Answer 1

Does declaring a operator T() imply that the cast always returns a T by value?

Yes.

The return type of conversion operators is implicitly exactly what they convert to.

[...] the type of the conversion function is “function taking no parameter returning conversion-type-id”.

§12.3.2 [class.conv.fct]

Answer 2

With clang++:

#include <iostream>

class   test
{
public:
  test(int n) : nb{n} {}

public:
  operator int() { return nb; }

  private:
    int nb;
};

int     main(void)
{
  test  t{42};

  int x = t;

  int& ref = t;   // error: non-const lvalue reference to type 'int' cannot bind to a value of unrelated type 'test'
  int&& rref = t; // compiles fine

  std::cout << x << std::endl;
}

Which suggest that you do return a temporary new value.

The real question to help you choose between your two cases is: do you want to let people modify your internal member (return a reference) and is that member expensive to copy (use a const reference instead of value) ?

Answer 3

Does declaring a operator T() imply that the cast always returns a T by value?

It means that the conversion operator will return as specified by T . Be that a reference, pointer or value. For example, given some type (as per the OP) Y :

operator Y();
operator Y&();
operator Y*();

Are all (with the cv-qualified variations) valid user defined conversions. To use Y as a reference, you will need to return it as a reference.

So, yes, casting to a T that is not a reference means that the return type is a value. This is inline with the general casting semantics - a value is returned.

Is there any difference in the semantics of the first and the second example?

Yes there are semantic differences. They would be the same semantic deferences as in other methods with reference vs. value return types. They would be different in the same way as the following two methods are different;

Y get_y_value();
Y& get_y_ref();

Notes

Mixing operator Y(); and operator Y&(); in the same class could lead to ambiguous overloads (at least clang complains about this, but gcc seems happy to mix the two).

I'm not going to opinion on which one is better here as the details of your situation are unclear. In general though, when implementing a user defined conversion, always consider how casts are typically performed and that rvalues are probably returned more often than not. With the advent of C++11, favour them being explicit as well; for the same reasons constructors are explicit (or not if specifically required).