Under what circumstances would a type's conversion operator to itself be invoked?

Question

Consider a type bar which has user-defined conversion operators to references of type bar:

struct bar
{
  operator bar & ();
  operator const bar & () const;
};

When would these conversions be applied? Moreover, what does it imply if these operators were deleted? Is there any interesting use of either feature?

The following program does not appear to apply either conversion:

#include <iostream>

struct bar
{
  operator bar & ()
  {
    std::cout << "operator bar &()" << std::endl;
    return *this;
  }

  operator const bar & () const
  {
    std::cout << "operator const bar &() const" << std::endl;
    return *this;
  }
};

void foo(bar x)
{
}

int main()
{
  bar x;

  bar y = x;         // copy, no conversion

  y = x;             // assignment, no conversion

  foo(x);            // copy, no conversion

  y = (bar&)x;       // no output

  y = (const bar&)x; // no output

  return 0;
}

Answer 1

C++11 §12.3.2

A conversion function is never used to convert a (possibly cv-qualified) object to the (possibly cv-qualified) same object type (or a reference to it), to a (possibly cv-qualified) base class of that type (or a reference to it), or to (possibly cv-qualified) void

Answer 2

The feature that you are allowed to define a conversion function from a type to itself, but that the conversion function is never used, can be a useful feature in template programming, where two type parameters may or may not refer to the same type, depending on the instantiation. Some code of mine relies on this feature. It saves having to provide specializations for cases where two or more of the type parameters end up referring to the same type.

Answer 3

I can't see any reason why it would ever be called. The conversion functions are called to... convert. If you already have the right type, there is absolutely no reason to add a conversion operation before the copy.