13

考虑以下类：

class A {

char *p;
int a, b, c, d;

public:
   A(const &A);
};

请注意，我必须定义一个复制构造函数才能对“p”进行深层复制。这有两个问题：

  1. 大多数字段应该简单地复制。一个一个地复制它们是丑陋的并且容易出错。

  2. 更重要的是，每当向类添加新属性时，都需要更新复制构造函数，这会造成维护的噩梦。

我个人想做类似的事情：

A(const A &a) : A(a)
{
   // do deep copy of p
   :::
}

所以先调用默认的拷贝构造函数，然后再进行深拷贝。
不幸的是，这似乎不起作用。

有没有更好的方法来做到这一点？一个限制 - 我不能使用共享/智能指针。

Sbi 的建议很有道理。我想我会创建包装类来处理资源。我不想使用 shared_ptr 因为 boost 库可能并非在所有平台上都可用（至少在标准发行版中不可用，OpenSolaris 就是一个例子）。

我仍然认为，如果你能以某种方式让编译器为你创建默认的构造函数/赋值运算符，并且你可以在它之上添加你的功能，那将会很棒。我认为手动创建的复制构造函数/赋值运算符函数创建起来很麻烦，维护起来也是一场噩梦。所以我个人的经验法则是不惜一切代价避免自定义复制构造函数/赋值运算符。

感谢大家的回复和有用的信息，并对我的问题中的拼写错误感到抱歉。我是用手机打字的。

4

9 回答 9

20

根据经验：如果您必须手动管理资源，请将每个资源包装到自己的对象中。

char*使用适当的复制构造函数将其放入自己的对象中，并让编译器为A. 请注意，这也涉及assignment 和 destroy，您在问题中没有提到，但仍然需要处理。
标准库有几种类型可供选择，其中std::string和std::vector<char>.

于 2010-07-07T07:44:54.370 回答
4

替换char*为std::string。

于 2010-07-07T07:31:14.567 回答
3

始终使用 RAII 对象来管理诸如原始指针之类的非管理资源，并为每个资源只使用一个 RAII 对象。一般避免使用原始指针。在这种情况下，使用std::string是最好的解决方案。

如果由于某种原因无法做到这一点，请将易于复制的部分考虑到基类或成员对象中。

于 2010-07-07T07:41:22.517 回答
3

您可以将您的可复制成员分成一个 POD 结构，并单独维护需要托管副本的成员。

由于您的数据成员是私有的，因此您班级的客户可能看不到它。

例如

class A {

char *p;

struct POData {
    int a, b, c, d;
    // other copyable members
} data;

public:
   A(const &A);
};

A(const A& a)
    : data( a.data )
{
    p = DuplicateString( a.p );
    // other managed copies...
    // careful exception safe implementation, etc.
}
于 2010-07-07T07:55:01.190 回答
2

你真的应该在这里使用智能指针。

这将避免重写复制构造函数和做作运算符 ( operator=)。

这两个都容易出错。

的一个常见错误是以operator=这种方式实现它：

SomeClass& operator=(const SomeClass& b)
{
  delete this->pointer;
  this->pointer = new char(*b.pointer); // What if &b == this or if new throws ?

  return *this;
}

当一个人这样做时会失败：

SomeClass a;
a = a; // This will crash :)

智能指针已经处理了这些情况，显然更不容易出错。

此外，智能指针boost::shared_ptr甚至可以处理自定义释放函数（默认情况下它使用delete）。在实践中，我很少遇到使用智能指针而不是原始指针不切实际的情况。

快速说明一下：boost智能指针类是仅标头设计的（基于模板），因此它们不需要额外的依赖项。（有时，这很重要）你可以只包括它们，一切都应该没问题。

于 2010-07-07T07:44:08.927 回答
0

所以先调用默认的拷贝构造函数，然后再进行深拷贝。不幸的是，这似乎不起作用。

有没有更好的方法来做到这一点？一个限制 - 我不能使用共享/智能指针。

如果我理解正确，您的问题，您可以考虑使用初始化函数：

class A
{
    int i, j;
    char* p;

    void Copy(int ii, int jj, char* pp); // assign the values to memebers of A
public:
    A(int i, int j, char* p);
    A(const A& a);
};

A::A(int i, int j, char* p)
{
    Copy(i, j, p);
}

A::A(const A& a)
{
    Copy(a.i, a.j, a.p);
}

也就是说，您确实应该考虑使用 RAII（人们不断推荐它是有原因的 :)）作为您的额外资源。

如果我不能使用 RAII，我仍然更喜欢为每个成员创建复制构造函数并使用初始化列表（实际上，即使使用 RAII，我也更喜欢这样做）：

A::A(int ii, int lj, char* pp)
    : i(ii)
    , j(jj)
    , p( function_that_creates_deep_copy(pp) )
{
}

A::A(const A& a)
    : i(a.i)
    , j(a.j)
    , p( function_that_creates_deep_copy(a.p) )
{
}

这具有“明确性”的优点并且易于调试（您可以介入并查看它对每次初始化的作用）。

于 2010-07-07T08:24:52.710 回答
0

问题是，你的类中真的需要一个具有深拷贝语义的指针吗？根据我的经验，答案几乎总是否定的。也许您可以解释您的情况，因此我们可能会向您展示替代解决方案。

也就是说，本文描述了具有深拷贝语义的智能指针的实现。

于 2010-07-07T07:50:44.207 回答
0

虽然我同意其他人的说法，您应该将指针包装在其自己的 RAII 类中，并让编译器综合复制构造函数、析构函数和赋值运算符，但有一种方法可以解决您的问题：声明（并定义）私有静态函数不同构造函数需要和通用的任何东西，然后从那里调用它。

于 2010-07-07T08:01:05.457 回答
0

除非您的班级有一个功能，即管理资源，否则您永远不应该直接管理任何资源。始终使用某种描述的智能指针或自定义管理类。通常，如果可以的话，最好保留隐式复制构造函数。这种方法还允许轻松维护析构函数和赋值运算符。

于 2010-07-07T11:52:53.633 回答