我可以为 const 和非常量实例编写不同的 copyCtor 吗？

Question

我有以下问题：

我有一个班级应该这样做：

Obj o;
Obj o1(o), o1=o; // deep-copies
const Obj c(o), c=o; // deep-copies
const Obj c1(c), c1=c; // shallow-copies
Obj o2(c), o2=c; // deep-copies

如果没有继承，我怎样才能做到这一点？ （我的意思是我会做 Const_obj 继承自 Obj 否则。）

编辑：

直接使用o.clone() 不是一种选择，因为这样我很容易通过意外不克隆引入错误。

编辑：

最后，使用Scott Meyers 的Effective C++ 的想法，有一个适当的、完整的懒惰评估解决方案。在下面查看我的答案。

Answer 1

不，你不能。

• 构造函数不能是 cv 限定的，因此不能强制它构造一个 const 对象。
• 函数的返回类型（包括运算符）不是其签名的一部分，因此您不能通过更改函数的返回类型来重载函数。

另外，如果可能的话，我会发现它真的令人困惑。只需制作适合您需要的方法，并以明确的方式命名即可。

Answer 2

看完Scott Meyers的Effective C++，以下是解决方法：

定义一个执行惰性评估的模板（使用引用计数）：

class Obj : private lazy<Obj_data>{};

惰性存储 Obj_data 私有，具有受保护的访问器，一个用于修改，一个用于只读访问。
如果需要，修饰符访问器首先深度复制Obj_data，然后移交对数据的引用。只读访问器只返回一个 const 引用。

这样做的总成本是存储 2 个额外的指针（一个用于数据，一个用于计数器）和一个计数器。

实现是这样的：

class lazy{
protected:
  lazy(const lazy&obj){lazy_copy(obj);}
  //(the required constructors, operator= ...)

  // accessors:
  const Obj_data& data() const {return *od;}
  Obj_data& mod_data() {make_private(); return *od;}
private:
  void lazy_copy(const lazy& obj);
  void make_private(); // this does the actual deep-copy, as late as possible.
private:
  counter*;
  Obj_data* od;
};

所以，读取和修改Obj 的属性就可以了

void Obj::method(){
   cout << data().some_attribute;    // simple read
   mod_data().i = 10;                // simple modify
   const Obj_data& const_d = data(); // assignable for lots of read-outs
   Obj_data& var_d = mod_data();     // assignable for lots of modifications.
}

请注意，您只能在 const 成员中使用 data()，因为 mod_data() 是类中的非常量函数，因此此解决方案是完全安全的，开销很小。

理论背景：问题中期望的行为是一个实现细节，与客户无关。因此我们通过私有继承来解决它。

Answer 3

您可以部分地使用虚拟参数：

class C {
public:
    struct NonStandardCopy { };

    C (const C &) {
        // "ordinary" copy constructor with default behavior
    }

    C (const C &, NonStandardCopy) {
        // "other" "copy" constructor
    }
};

C c = c1; // default
C c (c1); // default
C c (c1, C::NonStandardCopy ()); // non-default

编辑：仅克隆方法可能是您想要的（与移动语义一起，性能影响可能不会太大）：

class C {
private:
    struct DeepCopy { };
    struct ShallowCopy { };

    C (const C &) = delete;

    C (const C &, DeepCopy) {
        // deep copy
    }

    C (const C &, ShallowCopy) {
        // shallow copy
    }
public:
    // move constructor
    C (C && other) = default;

    const C clone () const { // 1
        // shallow copy
        return C (*this, ShallowCopy ());
    }

    C cloneToNonConst () const {  // 2
        // deep copy
        return C (*this, DeepCopy ());
    }

    C clone () { // 3
        return cloneToNonConst ();
    }
};

C o;
C o1 = o.clone (); // call 3
const C o2 = o1.clone (); // call 3
const C o3 = o2.clone (); // call 1
C c4 = o3.cloneToNonConst (); // call 2; o3.clone () will give error