C++ 标准向量C++；——深拷贝还是浅拷贝

我想知道复制向量是否是在复制向量及其值（而这不适用于数组，深度复制需要一个循环或memcpy）

你能解释一下吗

---

关于

在复制向量时，您正在进行深度复制。但是如果你的向量是指针的向量，你得到的是指针的副本，而不是指向的值

例如：

std::vector<Foo> f;
std::vector<Foo> cp = f; //deep copy. All Foo copied

std::vector<Foo*> f;
std::vector<Foo*> cp = f; //deep copy (of pointers), or shallow copy (of objects).
//All pointers to Foo are copied, but not Foo themselves

std:：向量f；
std：：向量cp=f//深度复制。全部复制
std：：向量f；
std：：向量cp=f//深度复制（指针）或浅层复制（对象）。
//所有指向Foo的指针都会被复制，但Foo本身不会被复制

矢量将调整大小，以便为对象留出足够的空间。然后它将遍历对象，并为每个对象调用默认的复制操作符

这样，向量的副本就是“deep”。向量中每个对象的副本都是为默认复制操作符定义的副本

在例子中。。。这是错误的代码：

#include <iostream>
#include <vector>

using namespace std;

class my_array{
public:
    int *array;
    int size;
    my_array(int size, int init_val):size(size){
        array = new int[size];
        for(int i=0; i<size; ++i)
            array[i]=init_val;
    }
    ~my_array(){
        cout<<"Destructed "<<array[0]<<endl;
        if(array != NULL)
            delete []array;
        array = NULL;
        size = 0;
    }

};

void add_to(vector<my_array> &container){
    container.push_back(my_array(4,1));
}

int main(){

    vector<my_array> c;
    {
        my_array a(5,0);
        c.push_back(a);
    }
    add_to(c);
    //At this point the destructor of c[0] and c[1] has been called.
    //However vector still holds their 'remains'
    cout<<c[0].size<<endl; //should be fine, as it copies over with the = operator
    cout<<c[0].array[0]<<endl;//undefined behavior, the pointer will get copied, but the data is not valid
    return 0;
}

#包括
#包括
使用名称空间std；
类我的数组{
公众：
int*数组；
整数大小；
my_数组（int size，int init_val）：大小（size）{
数组=新整数[大小]；
对于（int i＝0；i＋1），我将第二个例子看作浅拷贝。<代码> int *a，*b；a＝b；//浅拷贝< /代码>。在向量的情况下，我们不是在做这样的事情吗？BTW，它的深度，而不是DEAP：有时，当我看到这些术语在不同的帖子中被不同的使用时，我会感到困惑。有人可能会说，在指针的情况下，它们是肤浅的复制品；根据你对它们的解释，两者似乎都是正确的。这种困惑可能来自于“指针”和“指针对象”之间缺少区别指针只是普通的对象，它们的复制方式确实与人们期望的完全一致。人们对指针感到困惑。它不依赖于
Foo
的复制构造函数或复制赋值的实现吗？它不是最终调用的对象之一吗？（在这种情况下，是哪个？）@用户833771问题不是关于
unique\u ptr
。对于
unique\u ptr
，它不能被复制，你可以
移动它或创建一个新的，深度复制内容。不要对
vector
使用
memcpy
。vector中包含的对象可能不是POD，它们可能是具有虚拟函数的类。使用
memcpy
ode>std:：copy
或simple
vector
到
vector
赋值。“深”与“浅”的区别在默认值语义的语言中没有多大意义，也不会试图隐藏它使用指针的事实（因此指针是具有自己值的对象，不同于它们引用的对象）。拷贝始终是按值计算的，而这是否构成“深度”拷贝与“浅层”拷贝取决于您的定义。更好的是，应该是五条规则。：（您使用了旧的三条规则）实际上他实现了两条规则：）
#include <iostream>
#include <vector>

using namespace std;

class my_array{
public:
    int *array;
    int size;
    my_array(int size, int init_val):size(size){
        cout<<"contsructed "<<init_val<<endl;
        array = new int[size];
        for(int i=0; i<size; ++i)
            array[i]=init_val;
    }
    my_array(const my_array &to_copy){
        cout<<"deep copied "<<to_copy.array[0]<<endl;
        array = new int[to_copy.size];
        size = to_copy.size;
        for(int i=0; i<to_copy.size; i++)
            array[i]=to_copy.array[i];
    }

    ~my_array(){
        cout<<"Destructed "<<array[0]<<endl;
        if(array != NULL)
            delete []array;
        array = NULL;
        size = 0;
    }

};

void add_to(vector<my_array> &container){
    container.push_back(my_array(4,1));
}

int main(){

    vector<my_array> c;
    {
        my_array a(5,0);
        c.push_back(a);
    }
    add_to(c);
    //At this point the destructor of c[0] and c[1] has been called.
    //However vector holds a deep copy'
    cout<<c[0].size<<endl; //This is FINE
    cout<<c[0].array[0]<<endl;//This is FINE
    return 0;
}