Question

struct B 
{

};

struct A
{
    operator A&() const;
    operator B&() const;
};


int main()
{
    const A a;
    B& br = a;
    A& ar = a;  
}

Why can I create cast operator to B&, but not to A&.

May be it does not have much sense (one can use it to erase const modifier, as in example), but it at least inconsistent!

Answer 1

You can’t do this because it’s explicitly forbidden. N3290 § 12.3.2 states:

Such functions are called
conversion functions. No return type can be specified. If a conversion function is a member function, the
type of the conversion function (8.3.5) is “function taking no parameter returning conversion-type-id”. 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.

(Emphasis mine)

This is discussed further in a note:

These conversions are considered as standard conversions for the purposes of overload resolution (13.3.3.1, 13.3.3.1.4) and
therefore initialization (8.5) and explicit casts (5.2.9).

Which explains this decision – it would interfere with the built-in mechanics too much. (For little gain).

If you really want something non-const from a const object the only smart way to do this is constructing a new instance using the copy constructor.

As a work around you could introduce a lightweight intermediary (like a smart pointer):

struct B {};

struct A {};

namespace {
  B b_inst;
  A a_inst;
}

struct A_wrapper {
  A& inst;
  // This is perfectly fine: const alters the reference, not what it refers to
  operator A&() const { return inst; }
  operator B&() const { return b_inst; }
  A_wrapper() : inst(a_inst) {}
};

int main() {
  const A_wrapper a;
  B& br = a;
  A& ar = a;
}

But really, wanting to do this in the first place looks like a code smell.