I wonder whether copying a vector I am copying the vector with its values (whereas this is not working with array, and deep copy need a loop or memcpy).
我想知道是否复制一个向量我正在用它的值复制向量(而这不适用于数组,深度复制需要一个循环或memcpy)。
Could you hint to an explanation?
你能暗示解释一下吗?
Regards
2 个解决方案
#1
70
You are making a deep copy any time you copy a vector. But if your vector is a vector of pointers you are getting the copy of pointers, not the values are pointed to
复制矢量时,您正在制作深层复制。但是如果你的向量是一个指针向量,你得到的是指针的副本,而不是指向的值
For example:
std::vector<Foo> f;std::vector<Foo> cp = f; //deep copy. All Foo copiedstd::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#2
2
Vector will resize to have enough space for the objects. It will then iterate through the objects and call the default copy operator for every object.
Vector将调整大小以使对象具有足够的空间。然后它将遍历对象并为每个对象调用默认的复制操作符。
In this way, the copy of the vector is 'deep'. The copy of each object in the vector is whatever is defined for the default copy operator.
这样,矢量的副本就是“深”。向量中每个对象的副本是为默认复制运算符定义的任何副本。
In examples... this is BAD code:
在示例中......这是BAD代码:
#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;}This is BETTER code:
这是更好的代码:
#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;}#1
70
You are making a deep copy any time you copy a vector. But if your vector is a vector of pointers you are getting the copy of pointers, not the values are pointed to
复制矢量时,您正在制作深层复制。但是如果你的向量是一个指针向量,你得到的是指针的副本,而不是指向的值
For example:
std::vector<Foo> f;std::vector<Foo> cp = f; //deep copy. All Foo copiedstd::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#2
2
Vector will resize to have enough space for the objects. It will then iterate through the objects and call the default copy operator for every object.
Vector将调整大小以使对象具有足够的空间。然后它将遍历对象并为每个对象调用默认的复制操作符。
In this way, the copy of the vector is 'deep'. The copy of each object in the vector is whatever is defined for the default copy operator.
这样,矢量的副本就是“深”。向量中每个对象的副本是为默认复制运算符定义的任何副本。
In examples... this is BAD code:
在示例中......这是BAD代码:
#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;}This is BETTER code:
这是更好的代码:
#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;}