Virtual bases and default move and swap functions [n2583, n2584]

In a virtual inheritance hierarchy, the implicitly-declared assignment
operator is allowed to assign the base class multiple times
[[class.copy] 12.8/13]:

   struct V {
     V& operator=(V const&) { std::cout << "Foo!\n"; }
   };
   struct A : virtual V {};
   struct B : virtual B {};
   struct D : A,B {};

   int main() { D d1, d2; d1 = d2; }

In this example, it is unspecified how many times "Foo!" is printed
out, and many compilers will do the assignment twice. (In this
particular example, compliers could reasonably get it 'correct' and
only print "Foo!" once; add user-supplied assignment operators to A
and B and this is no longer the case.)

Generally, this is not a problem, as it is fairly unusual to store
data in virtual bases, and even when there is data present, in most
cases the assignment operator is idempotent meaning that the multiple
assignment is merely an inefficiency. The problem only arises if the
virtual base contains an object with non-standard assignment
semantics, such as a std::auto_ptr, and this is presumably rare enough
that the benefits of having implicitly-declared assignment operators
outweigh the confusion from rare examples where it misbehaves.

Papers n2583 and n2584 propose that C++0x gains default
implementations for move assignment operators and swap functions.
These have to be explicitly requested, which in the code above would
look like:

   struct D : A,B {
     D& operator=(D&&) = default;
     void swap(D&&) = default;
   };
   void swap(D&, D&) = default;

I think this is a good proposal, and over time, I would anticipate it
to be become good practice to add both of these to copyable classes as
a matter of course. However, in virtual inheritance hierarchies,
these two functions suffer from the same problem as the implicitly-
generated assignment operator. But in this case, it is compounded by
the fact that in a typical class, neither move assigning nor swapping
are idempotent operations (whereas typically copy assigning is). The
result is that, in a virtual inheritance hierarchy where a virtual
base contains state, the default swap and move assign functions will
almost always be wrong. (The case of move constructors can be made to
work, in the same way that copy constructors can.)

I don't know how common a scenario stateful virtual bases are, but
it's worth noting that the only example of a virtual base in the C++98
standard library (std::basic_ios) is stateful. And because of this,
it might be worth fixing n2583 and n2584 to cope with them. This
should be easy enough:

Define a stateless class to be a class type which either has no non-
static data members or which only has empty non-static data members,
where an empty type is defined as one for which std::is_empty tests
true [meta.unary.prop]. Then say that the default implementation of a
member swap function or move assignment operator is ill-formed if the
class has any non-stateless virtual bases.

Does this seem a reasonable suggestion?

I also wonder whether the default move assignment operator and move
constructors should be implicitly supplied much as copy constructors
and copy assignment operators are. There must surely be very
few instances where the copy constructors / assigment operators make
sense, but the move ones don't. (The converse is clearly not true:
lots of classes might reasonably be moveable but not copyable.)

--
Richard Smith

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]