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

Вот философская напыщенная речь:

1. Я не думаю, что виртуальное наследование может или должно быть частным. Вся суть виртуальной базы заключается в том, что наиболее производный класс владеет виртуальной базой, а не промежуточными классами. Таким образом, никакому промежуточному классу не должно быть позволено «забивать» виртуальную базу.

2. Позвольте мне повторить мысль: самый производный класс владеет виртуальной базой. Это очевидно в инициализаторах конструктора:

   D::D() : A(), B(), C() { }
   //       ^^^^
   //       D calls the virtual base constructor!
   

   В том же смысле все другие операции в D должны нести непосредственную ответственность за A. Таким образом, мы естественным образом приходим к написанию производной функции подкачки следующим образом:

   void D::swap(D & rhs)
   {
       A::swap(rhs);   // D calls this directly!
       B::swap(rhs);
       C::swap(rhs);
   
       // swap members
   }
   

3. Собирая все это вместе, у нас остается только один возможный вывод: вам нужно написать функции подкачки промежуточных классов, не меняя местами базу:

   void B::swap(B & rhs)
   {
       // swap members only!
   }
   
   void C::swap(C & rhs)
   {
       // swap members only!
   }
   

Теперь вы спрашиваете: «А что, если кто-то еще хочет унаследовать от D?» Теперь мы видим причину, по которой Скотт Мейер советует всегда делать нелистовые классы абстрактными: следуя этому совету, вы только реализуете последний swap функция, которая вызывает обмен виртуальной базы в конкретных, листовых классах.

Обновление: Здесь есть кое-что, связанное лишь косвенно: виртуальная подкачка. Мы продолжаем предполагать, что все нелистовые классы абстрактны. Во-первых, мы добавляем следующую «виртуальную функцию подкачки» в каждый базовый класс (виртуальный или нет):

struct A
{
    virtual void vswap(A &) = 0;
    // ...
};

Конечно, использование этой функции разрешено только идентичным типам. Это обеспечивается неявным исключением:

struct D : /* inherit */
{
    virtual void vswap(A & rhs) { swap(dynamic_cast<D &>(rhs)); }

    // rest as before
};

Общая полезность этого ограничена, но позволяет нам переключаться на объекты полиморфно, если мы знаем, что они одинаковы:

std::unique_ptr<A> p1 = make_unique<D>(), p2 = make_unique<D>();
p1->vswap(*p2);

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

Первое решение: реорганизуйте классы, чтобы они больше подходили для полиморфизма. Сделайте копирование защищенным. Удалить присвоение и swap(). Добавьте виртуальный clone(). Идея состоит в том, что классы следует рассматривать как полиморфные. Поэтому их следует использовать с указателем или интеллектуальным указателем. Переставленными или назначенными должны быть значения указателя, а не значения объекта. В таком контексте своп и присваивание только сбивают с толку.

Второе решение: сделайте B и C абстрактными и их указатели, чтобы не управлять временем жизни объекта. Деструкторы B и C должны быть защищенными и не виртуальными. Следовательно, B и C не будут производными классами объектов. Сделать B::swap() и C::swap() защищенными и не поменять местами подобъект A, можно переименовать или добавить комментарий, что теперь это дело унаследованных классов. Это устраняет множество возможностей нарезки объектов. Сделайте D::swap(), чтобы поменять местами подобъект. Вы получаете один обмен A.

Третье решение: заставьте D::swap() поменять местами подобъект. Таким образом, подобъект A будет поменять местами 3 раза и приземлится в нужное место. Неэффективно? В любом случае вся конструкция, вероятно, плохая идея. Я, например, не уверен, насколько хорошо здесь взаимодействуют виртуальные деструкторы и свопы, и здесь доступно множество способов нарезки объектов. Все это похоже на попытку создания операторов виртуального присваивания, что является плохой идеей в C ++.

Если что-то унаследовано от D в своем порядке, то он должен убедиться, поменяв местами или не переставляя подобъект A, что количество перестановок A нечетное. Это становится контролем, поэтому следует взять на себя ответственность и исправить.

Идиома private virtual - это один из способов сделать класс финальным в C ++. Ничто не должно наследовать от него. Интересно, что вы спросили. Если вы когда-нибудь им воспользуетесь, обязательно прокомментируйте, это сбивает с толку большинство читателей кода.