考虑经典的虚拟继承菱形层次结构。我想知道在这种层次结构中 copy-and-swap 习语的正确实现是什么。

example有点人为 - 而且它不是很聪明 - 因为它可以很好地处理 A、B、D 类的默认复制语义。但只是为了说明问题 - 请忘记示例弱点并提供解决方案。

所以我有从 2 个基类 (B<1>,B<2>) 派生的类 D - 每个 B 类实际上都继承自 A 类。每个类都有使用 copy-and-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;
};

B

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 私有(private)继承时呢？

最佳答案

这是一个哲学咆哮:

1. 我认为虚拟继承不能也不应该是私有(private)的。虚拟基的全部要点是最派生的类拥有虚拟基，而不是中间类。因此，不应允许任何中间类“霸占”虚拟基础。

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 派生怎么办？现在我们明白了 Scott Meyer 建议始终将非叶类抽象化的原因:遵循该建议，您只 实现最终的 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);

关于c++ - 在虚拟继承中交换和复制成语的正确方法是什么？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/12314820/