c++ - 复制构造函数和赋值运算符

Question

如果我重写operator=，复制构造函数会自动使用 new 运算符吗？同样，如果我定义了一个复制构造函数，是否会operator=自动“继承”复制构造函数的行为？

Answer 1

不，他们是不同的运营商。

复制构造函数用于创建新对象。它将现有对象复制到新构造的对象。复制构造函数用于从旧实例初始化新实例。当按值将变量传递给函数或作为函数的返回值时，不一定要调用它。

赋值运算符是处理一个已经存在的对象。赋值运算符用于将现有实例更改为与右值具有相同的值，这意味着如果该实例具有内部动态内存，则必须销毁并重新初始化该实例。

有用的链接：

• 复制构造函数、赋值运算符等
• C ++中的复制构造函数和=运算符重载：通用函数可能吗？

Answer 2

不会。除非您定义复制 ctor，否则将生成默认值（如果需要）。除非您定义 operator=，否则将生成默认值（如果需要）。它们不相互使用，您可以独立更改它们。

Answer 3

不，它们是不同的对象。

如果您担心复制构造函数和赋值运算符之间的代码重复，请考虑以下成语，命名为copy 和 swap：

struct MyClass
{
    MyClass(const MyClass&); // Implement copy logic here
    void swap(MyClass&) throw(); // Implement a lightweight swap here (eg. swap pointers)

    MyClass& operator=(MyClass x)
    {
        x.swap(*this);
        return *this;
    }
};

这样，operator=将使用复制构造函数来构建一个新对象，该对象将在函数退出时与旧对象交换*this并释放（与旧的内部）。this

Answer 4

不。

并且一定要看看三规则 （或考虑右值时的五规则）

Answer 5

考虑以下 C++ 程序。
注意：我的“矢量”类不是标准库中的类。
我的“矢量”类接口：

#include <iostream>

class Vector {
private:
    double* elem; // elem points to an array of sz doubles
    int sz;
public:
    Vector(int s);  // constructor: acquire resources
    ~Vector() { delete[] elem; }   // destructor: release resources
    Vector(const Vector& a);               // copy constructor
    Vector& operator=(const Vector& a);    // copy assignment operator
    double& operator[](int i){ return elem[i]; };
    int size() const {return sz;};
};

我的“向量”类成员实现：

Vector::Vector(int s)  // non-default constructor
{
    std::cout << "non-default constructor"<<std::endl;
    elem = {new double[s]};
    sz =s;
    for (int i=0; i!=s; ++i)      // initialize elements
        elem[i]=0;
}

Vector::Vector(const Vector& a)   // copy constructor
        :elem{new double[a.sz]},
         sz{a.sz}
{
    std::cout << "copy constructor"<<std::endl;
    for (int i=0; i!=sz; ++i)    // copy elements
        elem[i] = a.elem[i];
}

Vector& Vector::operator=(const Vector& a)     // copy assignment operator
{
    std::cout << "copy assignment operator"<<std::endl;
    double* p = new double[a.sz];
    for (int i=0; i!=a.sz; ++i)
        p[i] = a.elem[i];
    delete[] elem;         // delete old elements
    elem = p;
    sz = a.sz;
    return *this;
}

int main(){
    Vector v1(1);
    v1[0] = 1024;    // call non-default constructor
   
    Vector v2 = v1;   // call copy constructor  !!!!

    v2[0] = 1025;
    std::cout << "v2[0]=" << v2[0] << std::endl;

    Vector v3{10};  // call non-default constructor
    std::cout << "v3[0]=" << v3[0] << std::endl;

    v3 = v2;     // call copy assignment operator  !!!!
    std::cout << "v3[0]=" << v3[0] << std::endl;
}

然后，程序输出：

non-default constructor
copy constructor
v2[0]=1025
non-default constructor
v3[0]=0
copy assignment operator
v3[0]=1025

总结一下：

1. Vector v2 = v1;导致调用复制构造函数。
2. v3 = v2; 导致调用复制赋值运算符。

在案例 2 中，对象v3已经存在（我们已经完成了：）Vector v3{10};。复制构造函数和复制赋值运算符之间有两个明显的区别。

• 复制构造函数不需要删除旧元素，它只是copy construct一个新对象。（因为它Vector v2）
• 复制构造this函数不需要返回指针。（此外，所有构造函数都不返回值）。

Answer 6

不，他们不是同一个运营商。