如何复制构造函数指针向量C ++

Question

I'm trying to create a copy constructor for a class "Table" with the following fields:

private:
    int id ;
    int capacity;
    bool open;
    std::vector<Customer*> customersList;
    std::vector<OrderPair> orderList;

I want to make a deep copy of all the fields and I've written the following code and I'm not sure I did a deep copy on the customersList since its a pointers vector. Can someone tell me if I made a deep or sallow copy? Thank you in advance.

the code:

Table(const Table& t): capacity(t.getCapacity()), open(t.isOpen()), id(t.getId()){
    std::vector<Customer*> tmp(t.customersList);
    customersList = tmp;
}

Or maybe I over copied and I should only do this? :

Table(const Table& t): customersList(t.customersList), capacity(t.getCapacity()), 
open(t.isOpen()), id(t.getId()){}

Thanks again!

Answer 1

Can someone tell me if I made a deep or sallow copy?

You made both/either... depending on what level of indirection you're considering.

The copy constructor of std::vector does a deep copy. That is: the vector customersList in the original object, and the vector customersList in the constructed object refer to different internal buffers. If you add a pointer to one, it won't automatically be reflected in the other vector.

However, the elements inside the vector are pointers. The pointers have same values, and point to the same Customer objects, and no Customer objects were copied. As such the copy is shallow.

---

Both suggestions that you show have same result, but the latter is better because it does only one operation with the vector (copy construction) rather than three (default construction of member, copy construction of local, copy assignment of member). If the functionality is correct, even simpler way to achieve same is to use the implicitly generated copy constructor: Table(const Table& t) = default; It does the same, except members are accessed directly, instead of through member functions.

But indeed, you need to consider what you want to copy deeply. Do you need copies of Customer objects? Then you do need a custom copy constructor that copy-initializes those Customer objects. If you do, then you probably should be using a vector of smart pointers rather than bare pointers (assuming you need pointers at all).

---

I wanted to create another vector that will contain new pointer - a new memory allocation, but with the same data. In other words, I want to copy the data to a new memory and save the new pointers in the customersList field.

In that case your copy constructor does not do what you want. You have new pointers, which don't have new values, and no memory allocation for customer objects (there is a memory allocation for the vector though).

How can I do that ?

You can write a loop that iterates over the vector that is to be copied. Within the loop, you can allocate new customer objects, and copy initialize them with the ones pointed by the vector. Then insert the pointer newly allocated pointer to the member vector that is being constructed.

Note that the pointers will in that case be owning. You should never have owning bare pointers. To re-iterate: In this case you should use smart pointers (assuming you need pointers at all).

Answer 2

Should you need a non-polymorphic answer in C++98/03. It handles that some pointers in your customersList might no longer point anywhere.

Table(Table const &t) : id(t.id), capacity(t.capacity), open(t.open), orderList(t.orderList) {
    customersList.reserve(t.customersList.size());
    std::vector<Customer *>::const_iterator b = t.customersList.begin();
    std::vector<Customer *>::const_iterator const e = t.customersList.end();
    for (; b != e; ++b) {
        if (*b) {
            customersList.push_back(new Customer(**b));
        } else {
            customersList.resize(customersList.size() + 1);
        }
    }
}

Answer 3

std::vector<Customer*> implies that it does not own Customer objects, merely refers to ones existing elsewhere. In this case you can use compiler-generated copy constructor that does member-wise (shallow) copy for you. Eg:

Table(const Table& t) = default;

Answer 4

No, you haven't copied the things being pointed to by those vector elements. If I've guessed at your requirement correctly, you'll need to go ahead and do that "manually":

Table(const Table& t): capacity(t.getCapacity()), open(t.isOpen()), id(t.getId()){
    customersList.reserve(t.customersList.size());
    for (const auto old : t.customersList)
       customersList.push_back(new Customer(*old));
}

If Customer is the base of an inheritance hierarchy, you're going to need a virtual Customer* clone() member function in each derived class that does the right new , so as to avoid slicing. If it isn't, why store pointers at all? Store values instead and save yourself this entire trouble.

By the way I hope you're properly managing the lifetime of these pointees, including delete . Overall it would generally be better if you used some kind of smart pointer instead of Customer* .