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

Question

I have a class A , which has as a member a pointer to a vector of pointers ( current ), the vector which contains a pair of an integer and an object of class B . I need to be able to create copies for objects of class A , and for that I use a Clone function (see code below). However, when I use this function, the pointers seem to be pointing to the same memory location, instead of different ones. I think the solution to this is to implement a copy constructor for my class in order to be able to properly copy my objects, but I am failing to do so.

Here is how my class looks like and the several tries I had for implementing the copy constructor:

class A {
public:
    A();
    A(const A &a);
    ~A();
    A* Clone() {return new A(*this);}
    std::vector<std::pair<unsigned int, B*>> *current;
};

EDIT: The constructor and destructor are implemented as follows:

A::A() {
    current = new vector<std::pair<unsigned int, B*>>;
}

A::~A() {
    std::vector<std::pair<unsigned int, B*>>::iterator cit = current->begin(), cend = current->end();
    for (; cit != cend; ++cit) {
        delete cit->second;
    }
    delete current;
}

Option #1:

A::A(const A &a){
    *current = *a.current;
}

Option #2:

A::A(const A &a){
    for(int i = 0; i < current->size(); i++) {
        (*current)[i] = (*a.current)[i];
    }
}

Option #3:

A::A(const A &a){
    for(int i = 0; i < current->size(); i++) {
        (*current)[i].first = (*a.current)[i].first;
        (*current)[i].second = new B((*a.current)[i].second);
    }
}

Options #1 and #2 give me segmentation fault, while for #3 I get the error: no match for operator *

Which is the correct way to implement the copy constructor and also should my Clone function be implemented differently?

Answer 1

Your constructor does not initialise the current member at all. In any of the options.

From there, accessing its value (ie the value of the pointer named current ) gives undefined behaviour. And so does dereferencing it. The usages of *current or *a.current in all options (and variations therefore) therefore ALL give undefined behaviour.

If you insist that the member current must be a pointer, it must be initialised in ALL constructors. For example, the constructor A::A() (which you haven't shown) must look something like

 A::A() : current(new std::vector<std::pair<unsigned int, B*>>(0))
 {
     //   initialised current with no elements
     // add pairs to the vector

     current->push_back(std::make_pair(0U, new B));
     current->push_back(std::make_pair(42U, new B));
 }

and the copy constructor must start with something akin to

A::A(const A &a) : current (new std::vector<std::pair<unsigned int, B *>>(a.current->size())
{
    for(int i = 0; i < current->size(); i++)
    {
        (*current)[i].first = (*(a.current))[i].first;
        (*current)[i].second = new B((*(a.current))[i].second);
    }
}

More generally, however, there is actually no reason for current to be a pointer created using operator new . In that case the constructors could be simplified to

 A::A() : current(0)
 {
     // add pairs to the vector

     current.push_back(std::make_pair(0U, new B));
     current.push_back(std::make_pair(42U, new B));
 }

and the copy constructor to

A::A(const A &a) : current (a.current.size())
{
    for(int i = 0; i < current.size(); i++)
    {
        current[i].first = a.current[i].first;
        current[i].second = new B(a.current[i].second);
    }
}

You've also provided no compelling information to suggest that current needs to be vector<pair<unsigned, B *>> rather than vector<pair<unsigned, B>> . If the vector doesn't need to hold pointers (ie it holds objects directly) then, practically, you will not need to define the copy constructor at all - the compiler-generated default will suffice. And your code will not need to use operator new at all (except, possibly, in A::Clone() ).

Note that, if you do actually need to hand-roll a copy constructor, you will probably need to also hand-roll an operator=() and a destructor. Look up "rule of three" (before C++11) or (C++11 and later) "rule of five" and "rule of zero" for more information.