C++ Templates: Byval/Reference interfering with eachother

Here's a simplified version of my problem. I have a property class. It has data like has_initalized and such which i removed for this example.

When i call a function which uses T its fine. However T& isnt so i decided to write a T& version of it. But this causes all functions which uses plain T to get a compile error. Why is T& interfering with that? For this example how do i get both functions (Q and W) to work without changing main()?

template <class T>
class Property {
    T v;
    Property(Property&p) { }
public:
    Property() {}
    T operator=(T src) { v = src; return v; }
    operator T() const { return v; }
    operator T&() const{ return v; }
    T operator->()开发者_StackOverflow { return v; }
};

class A{};

void Q(A  s){}
void W(A& s){}

int main(){
    Property<A> a;
    Q(a);
    W(a);
}

There is nothing in the overloading rules of C++ which allows the compiler to choose between operatorT() and operatorT&() in the call to Q. So removing the

operator T() const { return v; }

will also remove the ambiguity. But then you'll have a problem because returning a non const reference to a member in a const function is not possible.

For your Q, you can use both conversion functions. You can make the compiler prefer one over the other by making one non-const.

operator T() const { return v; }
operator T&() { return v; }

Now for Q, the operator T& is taken. This way will also fix the call to W to get a non-const reference. You can also return a const reference from the other

operator T const&() const { return v; }
operator T&() { return v; }

This way will still prefer the second conversion function for Q, but if your object a is const and you initialize a const reference, you won't always require to copy v.