C++ - Shallow copying a pointer. Why is this code working?

Question

To my understanding of the subject: A shallow copy is when the non-pointer types of an object are copied to another object. Shallow copies can't be done when an object has pointers because, the object being copied will get the address of that pointer, and when either of the two objects are deleted, the other will be left dangling since they were pointing to the same location in memory. A deep copy is used when pointers are involved because it reserves a space separate from the original object's space and just copies the contents from one memory location to another. This way, when one of the objects is deleted, teh other isn't left dangling. That said, I would like to know why this program is working even though I've done a shallow copy of a pointer

struct aStruct {
    int *i;
    aStruct(int *p) : i(p) {
        cout << "Created aStruct" << endl;
    }
    aStruct(const aStruct &s) {
        cout << "Copying aStruct" << endl;
        i = s.i;
    }
    aStruct &operator=(const aStruct &s) {
        cout << "Assigning aStruct" << endl;
        i = s.i;
        return *this;
    }
};

int main() {
    int *x = new int(3);
    aStruct s1(x);
    aStruct s2 = s1;
    int *y = new int(4);
    aStruct s3(y);
    s3 = s1;
}

s1, s2, and s3 all have their variable i pointing to the same place. So when the end of the main() function is reached and one of them is destroyed, shouldn't the others be left dangling causing an error? My program works fine. Could someone please be kind enough to explain this to me?

Thanks all

When the structure is destroyed, it doesn't do anything to the item it points to, because you didn't write a destructor, and didn't use a smart pointer. — Ben Voigt, Apr 18 '16 at 22:54
But I thought a default a destructor is called at the end of the block of code to remove all pointers. Is that not right? — this is a long display name, Apr 18 '16 at 22:55
The default destructor is destructing the object itself, with the "object" in question being a pointer. It **does not** do anything with the data being pointed to. Additionally though, your object is actually trivial so in reality, there's no actual destructor required here. — Olipro, Apr 18 '16 at 22:56
@thisisalongdisplayname _"But I though a default a destructor is called ..."_ No, there's no such thing. — πάντα ῥεῖ, Apr 18 '16 at 22:56
@πάνταῥεῖ If a class has no user-declared destructor, a destructor is implicitly declared as defaulted. [class.dtor]/4 — M.M, Apr 18 '16 at 23:14
@M.M But there's no such mechanism for pointers going out of scope. — πάντα ῥεῖ, Apr 18 '16 at 23:16
Right... a default destructor `~aStruct()` *is* called , but that destructor does not `delete` anything — M.M, Apr 18 '16 at 23:17

score 4 · Answer 1 · answered Apr 18 '16 at 22:55

4

You are copying the pointer, not the data. Each object here is an object in its own right, additionally, you seem to be under the impression that C++ is garbage-collected. it is not (except in some uncommon implementations)

Your program basically leaks memory and is only cleaned up by virtue of the OS releasing whatever your process consumed after it terminated. Consequently, all your pointers are pointing to perfectly valid memory throughout the lifetime of your application.

answered Apr 18 '16 at 22:55

Olipro

3,489
19
25

If OP assumed that C++ is garbage collected, then it would not make sense to assume that there are dangling pointers. I think OP assumes that when a pointer is destroyed, it's pointed object is destroyed as well. Which of course is not the case. – eerorika Apr 18 '16 at 22:58

score 3 · Answer 2 · edited May 23 '17 at 12:24

Unfortunately, there is no concept of Deep and Shallow pointers in C++. The notion of references in Java and C# is different from pointers in C++. You should read on

Take it this way, in C++, Pointers refers to whatever object is in the memory location it, the pointer is pointing to.

So, what you are doing is copying the allocated location into your constructor into the object... When the destructor runs, of cause the entire object is freed from memory (dead), including the pointer int* i that is a data member. But the memory location allocated by new isn't freed until someone calls that same location with a delete.

If you ignore the rest of this answer, and you'd be stupid to do so, read the link on the Rule of Three. — user4581301, Apr 18 '16 at 23:31

C++ - Shallow copying a pointer. Why is this code working?

2 Answers2