【问题标题】:Is it a good practice to point to a new address on free store when dynamicly allocating?动态分配时指向免费商店的新地址是一种好习惯吗?
【发布时间】:2014-01-01 01:50:29
【问题描述】:

下面是C++ Primer 5th Edition的一个练习:

练习 13.22:假设我们希望 HasPtr 表现得像一个值。 也就是说,每个对象都应该有自己的字符串副本 对象点。我们将展示复制控制的定义 下一节中的成员。然而,你已经知道你所知道的一切 需要知道实现这些成员。编写 HasPtr 副本 继续阅读之前的构造函数和复制赋值运算符。(第 511 页)

HasPtr 类代码:

class HasPtr
{
public:
    //! default constructor
    HasPtr(const std::string &s = std::string()):
        ps(new std::string(s)), i(0) { }

    //! copy constructor
    HasPtr(const HasPtr& hp) : ps(new std::string(*hp.ps)), i(hp.i) { }

    HasPtr&
    operator = (const HasPtr& hp);

    ~HasPtr()
    {
        delete ps;
    }

private:
    std::string *ps;
    int    i;
};

我的这个复制赋值运算符的代码:

HasPtr&
HasPtr::operator = (const HasPtr &hp)
{
    delete ps;
    ps = new std::string(*hp.ps);

    i  = hp.i;

    return *this;
}

本书以下部分提供的代码:

HasPtr& 
HasPtr::operator = (const HasPtr &rhs)
{
    auto newp = new string(*rhs.ps);   // copy the underlying string
    delete ps;       // free the old memory
    ps = newp;       // copy data from rhs into this object
    i = rhs.i;
    return *this;    // return this object
}

通过一步一步的执行,我发现两个代码有细微的差别。在我的代码中,它不会更改ps 指向的地址,而书中的代码使ps 指向一个新地址。我想知道这种细微的差异是否有任何重要意义?在类似情况下,我是否应该始终将指针更改为新地址?为什么?

【问题讨论】:

  • 我建议使用复制交换习语。
  • copy-swap 很好,因为它在一般情况下很有效,并且倾向于避免许多此类代码所具有的自分配和异常安全问题。
  • 不清楚为什么字符串是指针?字符串的内容已经存储在堆上。如果您利用移动语义,则在本地存储它不会影响性能。如果您倾向于将其保留为指针,请考虑使用智能指针。此代码不是异常安全的。我也建议阅读复制交换习语。
  • 没错,我猜这段代码是为了演示如何创建一个 RAII 类,但是如果你杀死指针,你就不需要析构函数、复制构造函数或复制赋值运算符.

标签: c++ pointers dynamic-memory-allocation copy-assignment


【解决方案1】:

您的代码在自分配和异常方面存在问题:假设内存分配引发了std::bad_alloc 异常。编码时,您应该始终假设内存分配可能出错,尽管实际上很少发生。在代码中

delete ps;
ps = new std::string(*hp.ps);

ps 将在第二行代码抛出异常时指向过时的成员。顺便说一句,如果您最终自行分配对象,您实际上delete 只有在访问它之前的内存。所以最好先复制右边的内容,然后放东西,最后释放资源。

碰巧,这些正是

的操作
  1. 复制构造函数
  2. swap() 操作通常需要用于持有资源的任何类型
  3. 析构函数

利用这三个操作的方式称为复制和交换成语:

T& T::operator=(T other) {
    this->swap(other);
    return *this;
}

【讨论】:

  • 注意签名更改。此特定代码使用按值传递来进行复制构造。这样做是可选的,而不是在操作符内部进行复制构造,但这样代码更小更干净。
【解决方案2】:

在功能上我只能看到一个区别。

    delete ps;
    ps = new std::string(*hp.ps);

如果内存不足,对new std::string 的调用可能会引发异常。在你的情况下,ps 仍然有旧的已删除字符串的地址——所以它格式不正确。如果您从异常中恢复,有人可能会取消对 ps 的引用,并且会发生不好的事情。

    auto newp = new string(*rhs.ps);   // copy the underlying string
    delete ps;       // free the old memory
    ps = newp;       // copy data from rhs into this object

在教科书代码中,ps 在分配新字符串之前不会被删除。例外情况下,ps 仍指向有效字符串,因此您没有格式错误的对象。

一个问题的多少取决于几个不同的事情,但通常最好的做法是避免出现任何格式错误的对象。

【讨论】:

    【解决方案3】:

    您的版本对于自分配是不安全的。

    delete ps;
    ps = new std::string(*hp.ps);
    

    在这里,如果进行自赋值,您可能会同时删除源和目标中的 ps,从而使其在 new 语句中的使用错误(但在大多数情况下它可能具有欺骗性)。

    你可以将new的值直接赋给你的成员变量,但不能在知道是否需要之前就随意删除ps。

    如果您在编写代码之前测试了自我赋值,例如if (this!=&hp),那么它会更好,但仍然不理想(请参阅其他地方的异常安全 cmets)。

    【讨论】:

      【解决方案4】:

      您的代码中实际上存在两个问题:

      • 自行分配
      • 异常安全

      您通常希望您的成员函数提供强大的异常保证,即当分配失败时(在您的情况下,它可以在operator new 或string 的复制构造函数中),程序状态不会改变。

      我认为现代做法是提供swap 函数并让赋值调用复制构造函数。比如:

      void HasPtr::swap(HasPtr& rhs)
      {
          std::swap(this.ps, rhs.ps);
          std::swap(this.i, rhs.i);
      }
      
      HasPtr(const HasPtr& rhs)
      {
          ps = new string(*rhs.ps);
          i = rhs.i;
      }
      
      HasPtr& operator=(const HasPtr& rhs)
      {
          HasPtr temp(rhs);
          this.swap(temp);
          return *this;
      }
      

      【讨论】:

        猜你喜欢
        • 2016-11-07
        • 1970-01-01
        • 1970-01-01
        • 2021-01-21
        • 2018-01-22
        • 1970-01-01
        • 2016-05-23
        • 1970-01-01
        • 2016-12-20
        相关资源
        最近更新 更多