Question

我有一个对象构造函数，它接受一个指向const对象的const指针

A::A( const B* const ex): m_B(B){};

其中m_B：

const B* const m_B;

我现在正在尝试创建一个复制构造函数和赋值运算符我没有运气就试过以下。

复制构造函数：

A::A( const A& cpy): *m_B(*cpy.m_B) {}

这不起作用......我该如何处理？作业运营商：

A& A::operator=(const A& rhs) {

 *m_B = *rhs.m_B // I know this won't work because const cannot be assigned 
                 // error: assignment of read-only data-member
}

任何想法如何解决这个问题？

Answer 1

如果你想要深拷贝，为什么你有一个指针？只是有一个原始对象。

class B{
  // ...
};

class A{
  const B _b;
public:
  A(A const& other)
    : _b(other._b) {}

private:
  // no assignment operator, since const objects can't be reassigned
  A& operator=(A const&); // undefined
};

Answer 2

~~问题是，构造函数没有返回值。~~

~~并且赋值运算符为operator=，而不是operator()。~~

在构造函数中，您获取了一个指针并保存了指针，而不是指针所指向的对象的内容。如果你采用这种语义，你应该只复制指针而不是复制内容:(或者你还有别的东西可以实现吗？）

class B;

class A {
public:
    const B* m_b;
    A( const B* const ex): m_B(ex){};

    //copy constructor
    A(const A& cpy): m_B(cpy.m_B){};
    //assignment operator
    A& operator=(const A&cpy) {m_B = cpy.m_B;};
};

Answer 3

赋值运算符可能必须使用new创建新实例：

A& A::operator=(const A& rhs) {
    m_B = new B(rhs.m_B);
    return *this;
}

当然，您必须跟踪这一点，因此如果您分配指针，则可以delete指针。如果您不想跟踪，请在构造函数中使用new。

甚至更好，使用新的shared_ptr根本不需要关心指针。

Answer 4

＆＃34;放置新＆＃34;在分配具有常量指针的对象时，运算符非常有用。

class ref
{
public:
  // Normal constructor creates new immutable reference.
  ref(const char* const ptr, size_t len): m_ptr(ptr),m_len(len) {}
  // Copy constructor creates new copy of existing immutable reference.
  ref(const ref& o): m_ptr(o.m_ptr),m_len(o.m_len) {}
  // Assignment operator replaces existing immutable reference with another one.
  // Previous reference is gone.
  ref& operator=(const ref& o) { new (this) ref(o.m_ptr, o.m_len); return *this; }
private:
  const char* const m_ptr;
  size_t m_len;
}

深度复制const指向const对象的指针

4 个答案: