Каков правильный подход для обмена и копирования в виртуальном наследовании?

Рассмотрим классическую алмазную иерархию виртуального наследования. Интересно узнать, как правильно использовать в такой иерархии идиомы копирования и обмена.

пример это немного искусственно — и не очень умно — так как это будет хорошо работать с семантикой копирования по умолчанию для классов A, B, D. Но просто, чтобы проиллюстрировать проблему — пожалуйста, забудьте о примерах слабых мест и предоставьте решение.

Итак, у меня есть класс D, полученный из 2 базовых классов (B<1>, В<2>) — каждый из классов B наследуется практически от класса A. Каждый класс имеет нетривиальную семантику копирования с использованием идиомы copy и swap. Наиболее производный класс D имеет проблемы с использованием этой идиомы. Когда это вызывает B<1> и B<2> обменять методы — он дважды меняет членов виртуального базового класса — так что подобъект остается неизменным !!!

A:

class A {
public:
A(const char* s) : s(s) {}
A(const A& o) : s(o.s) {}
A& operator = (A o)
{
swap(o);
return *this;
}
virtual ~A() {}
void swap(A& o)
{
s.swap(o.s);
}
friend std::ostream& operator << (std::ostream& os, const A& a) { return os << a.s; }

private:
S s;
};

В

template <int N>
class B : public virtual A {
public:
B(const char* sA, const char* s) : A(sA), s(s) {}
B(const B& o) : A(o), s(o.s) {}
B& operator = (B o)
{
swap(o);
return *this;
}
virtual ~B() {}
void swap(B& o)
{
A::swap(o);
s.swap(o.s);
}
friend std::ostream& operator << (std::ostream& os, const B& b)
{ return os << (const A&)b << ',' << b.s; }

private:
S s;
};

D:

class D : public B<1>, public B<2> {
public:
D(const char* sA, const char* sB1, const char* sB2, const char* s)
: A(sA), B<1>(sA, sB1), B<2>(sA, sB2), s(s)
{}
D(const D& o) : A(o), B<1>(o), B<2>(o), s(o.s) {}
D& operator = (D o)
{
swap(o);
return *this;
}
virtual ~D() {}
void swap(D& o)
{
B<1>::swap(o); // calls A::swap(o); A::s changed to o.s
B<2>::swap(o); // calls A::swap(o); A::s returned to original value...
s.swap(o.s);
}
friend std::ostream& operator << (std::ostream& os, const D& d)
{
// prints A::s twice...
return os
<< (const B<1>&)d << ','
<< (const B<2>&)d << ','
<< d.s;
}
private:
S s;
};

S это просто строка для хранения классов.

При копировании вы увидите, что A :: s остается неизменным:

int main() {
D x("ax", "b1x", "b2x", "x");
D y("ay", "b1y", "b2y", "y");
std::cout << x << "\n" << y << "\n";
x = y;
std::cout << x << "\n" << y << "\n";
}

И результат:

ax,b1x,ax,b2x,x
ay,b1y,ay,b2y,y
ax,b1y,ax,b2y,y
ay,b1y,ay,b2y,y

Возможно добавление B<N>::swapOnlyMeрешит проблему:

void B<N>::swapOnlyMe(B<N>& b) { std::swap(s, b.s); }
void D::swap(D& d) { A::swap(d); B<1>::swapOnlyMe((B<1>&)d); B<2>::swapOnlyMe((B<2>&)d); ... }

Но что, когда B наследует в частном порядке от A?