Why push_back doesn't push a copy of the source obj?

Question

My code is just like below:

class CDemo {
public:
    CDemo()
        : str(NULL){

          };
    ~CDemo() {
        if (str)
            delete[] str;
    };
    char* str;
};

void testVector() {
    CDemo c;
    c.str = new char[32];
    strcpy(c.str, "abcdef");
    vector<CDemo>* v = new vector<CDemo>();
    v->push_back(c);
    delete (v);
    return;
}

I know this is a code which will report a run-time error because I didn't explicitly define a copy constructor, so ,when testVector returned , the member field str will be freed twice, thus reporting an error.But what make me confused , is that when I debug to the line: delete(v), the visual studio shortcut is as below: enter image description here

I think the function push_back will lead to the call of the default copy constructor of object c, so, after push_back returned , the element of vector v should be a different object from c, but from the debug watch, I find they are the same address:0x00318100. Does it prove that they are actually the same object? Anyone can explain this?

It *does* push a copy of the object. You have two copies of the same pointer. — chris, Sep 01 '14 at 14:52
But the debugger is showing the address stored in `str`. That's exactly the thing you yourself say you *expect* to be the same. — Angew is no longer proud of SO, Sep 01 '14 at 14:53
The default copy constructor of `CDemo` copy the pointer value of `str`, not the pointed data. — NetVipeC, Sep 01 '14 at 14:55
That is the address of the char string and thus it's perfectly normal that they are the same — Marco A., Sep 01 '14 at 14:55

score 1 · Answer 1 · edited May 23 '17 at 11:57

It does push a copy of the CDemo object.

However, both copies contain the same value of their str pointers. That's what you're looking at in the debugger, and that's why both try to delete the same array.

To fix the double-deletion, either

Use std::string to correctly manage memory for you; or
Carefully implement a copy-constructor and copy-assignment operator to correctly copy the string contents, not the pointer, per the Rule of Three.

Unless you're teaching yourself how to manage dynamic memory, or have very special requirements, just use std::string. And in general, don't use new unless you really need to - in particular, there's no reason to dynamically allocate the vector.

score 0 · Answer 2 · answered Sep 01 '14 at 14:56

You're looking at the char* address which gets copied "as it is" once set and not at the address of an object.

The address of the pointers will probably be different (you can verify that by enabling the code disassembly mode and looking at the pointers involved and/or by looking at the stack and memory dump) but they do point at the same location.

score 0 · Answer 3 · answered Sep 01 '14 at 14:58

"c" might be stack allocated:

CDemo c ;

But you pushed a heap allocated pointer into "c":

c.str=new char[32];

So you could add another constructor that makes a own heap allocated copy of the content:

CDemo(const char* src) :str(new char[strlen(src)+1]) {
    strcpy(str, src);
};

and than use it this way:

vector<CDemo> v;
v.push_back(new CDemo("abcdef"));

Why push_back doesn't push a copy of the source obj?

3 Answers3