c++ - 复制构造函数(深层复制)c++

我正在做一个作业，该作业要求在构造带有指针的类时编写Big 3的函数实现。我似乎在复制构造函数方面遇到麻烦。我认为我在正确地执行其他2个操作。

class RealBox
{
private:
  float* m_reals;                     // Array of Real Numbers
  int m_boxsize;                      // number of Real Numbers in this box


public:
  // Purpose: Constructs an Real-Box
        // Preconditions:
        //     's' is greater than 0;
  // Postconditions:
  //     m_reals points to a dynamically allocated array of size 's'
  //     all elements of m_reals[] are initiallized to 'a'.

  RealBox(int s, float a);



  /*
   * --------- Big 3 Member Functions -----------
   */

  // Purpose: Destructor
  // Postconditions: m_reals[] deallocated
  ~RealBox();

  // Purpose: Operator=, performs a deep copy of 'rhs' into 'this' RealBox
  // Parameters: rhs, RealBox to be copied
  // Returns: *this
  // Postconditions: *this == rhs
  const RealBox& operator=(const RealBox& rhs);

  // Purpose: Copy Constructor
  // Parameters: rhs - RealBox to be copied
  // Postconditions:  *this == rhs
  RealBox(const RealBox& rhs);


  /*
   * ----- Simple Accessor Operations -----
   */

  // Purpose: Sets a value in the RealBox
  // Parameters: 'i' location to set
  //             'x' value to store
  // PreConditions: 'i' is between the boundaries of the RealBox
  // Postconditions:  element 'i' in the RealBox is set to 'x'
        void set( int i, float x);


  /*
   * ----- Complex Accessor Operations -----
   */

  // Purpose: prints the RealBox
  friend std::ostream& operator<< (std::ostream& out,
                                   const RealBox& box);
}; // RealBox

#include "realbox.h"
#include <iostream>
using namespace std;

RealBox::RealBox(int s, float a)
{
 m_reals = new float[s];
 for (int i=0; i < s; i++)
 {
  m_reals[i] = a;
 }
}

RealBox::~RealBox()
{
 delete [] m_reals;
 m_reals = NULL;
}
const RealBox& RealBox::operator =(const RealBox& rhs)
{
 if(this != &rhs)
   *this = rhs;
 return(*this);
}

RealBox::RealBox(const RealBox& rhs)
{
 m_reals = new float[m_boxsize];
 *this = rhs.m_reals;
}


void RealBox::set(int i, float x)
{
 m_reals[i] = x;
}

std::ostream& operator<< (std::ostream& out, const RealBox& box)
{
 out <<"[ ";
 for (int i = 0; i < box.m_boxsize; i++)
 {
  out << box.m_reals[i] << ", ";
 }
 out <<"]"<< endl;
 return(out);
}

当我尝试编译时，出现错误：


  realbox.cpp：在副本构造器“ RealBox :: RealBox（const RealBox＆）”中：
  realbox.cpp：33：8：错误：“ operator =”不匹配（操作数类型为“ RealBox”和“ float * const”）
  
  *这= rhs.m_reals;
          ^
  realbox.cpp：33：8：注意：候选人是：
  
  realbox.cpp：23：16：注意：const RealBox＆RealBox :: operator =（const RealBox＆）
   const RealBox＆RealBox :: operator =（const RealBox＆rhs）
                  ^
  realbox.cpp：23：16：注意：参数1从'float * const'到'const RealBox＆'的未知转换


我认为我的操作员=重载也是有问题的，但我不确定到底出了什么问题。直到我开始尝试修复时，它才给我该错误。它试图说我正在比较两种不同的数据类型，但是我不确定这是如何发生的。

最佳答案

这行：

*this = rhs.m_reals;

尝试将float*分配给RealBox对象。两种类型不兼容。

其次，构造对象时未能初始化m_boxsize。

您要做的是：

RealBox::RealBox(const RealBox& rhs)
{
  m_boxsize = rhs.boxsize;
  m_reals = new float[m_boxsize];
  for (int i = 0; i < m_boxsize; ++i )
     m_reals[i] = rhs.m_reals[i];
}

可以简化为：

RealBox::RealBox(const RealBox& rhs) : m_boxsize(rhs.m_boxsize),
                                        m_reals(new float[rhs.m_boxsize])
{
   std::copy(rhs.m_boxsize, rhs.m_boxsize + m_boxsize, m_reals);
}

另外，您的其他构造函数需要初始化m_boxsize变量：

RealBox::RealBox(int s, float a) : m_boxsize(s)
{
   m_reals = new float[s];
   for (int i=0; i < s; i++)
       m_reals[i] = a;
}

也可以缩短为：

RealBox::RealBox(int s, float a) : m_boxsize(s), m_reals(new float[s])
{
   std::fill( m_reals, m_reals + s, a);
}

std::fill和std::copy在<algorithm>标头中定义。



解决此问题后，赋值运算符将非常简单：

#include <algorithm>
//...
RealBox& RealBox::operator =(RealBox rhs)
{
    std::swap(rhs.m_reals, m_reals);
    std::swap(rhs.m_boxsize, m_boxsize);
    return *this;
}

复制/交换习语的使用使这一切成为可能。简单就可以。

What is the copy-and-swap idiom?