C++ Object Copy

Question

I'm just looking at the following code snippet:

#include<iostream>
#include<cstring>
using namespace std;

class String
{
private:
    char *s;
    int size;
public:
    String(const char *str = NULL); // constructor
    ~String() { delete [] s; }// destructor
    void print() { cout << s << endl; }
    void change(const char *); // Function to change
};

String::String(const char *str)
{
    size = strlen(str);
    s = new char[size+1];
    strcpy(s, str);
}

void String::change(const char *str)
{
    delete [] s;
    size = strlen(str);
    s = s + 1;
    s = new char[size+1];
    strcpy(s, str);
}

int main()
{
    String str1("StackOverFlow");
    String str2 = str1;

    str1.print();
    str2.print();

    str2.change("StackOverFlowChanged");

    str1.print();
    str2.print();
    return 0;
}

I expect the output as: StackOverflow, StackOverflow, StackOverflow, StackOverflowChanged.

Before str2.change("StackOverFlowChanged") line, both str1 and str2's s point to the same memory location. However, in change method, since the pointer value changed, I except now str1 and str2's s point to the different locations and this is not the case. Can somebody explain why this is the case?

score 1 · Accepted Answer · answered Aug 29 '20 at 16:08

After calling str2.change, str1 no longer has a valid pointer. Since the two objects were sharing the same pointer, by deleting the array in one object, the other object now points to a deleted array. Attempting to access the array pointed to by str1 is undefined behavior, so str1.print() is invalid code.

Now, in this particular case, odds are good that the new char[] in str2.change just so happens to return a pointer to an address identical to the one that was just deleted. After all, the memory was just freed up, and no other allocations were made in the meantime. So while str1's pointer is still invalid, it just so happens to work out to pointing at a valid string by the time str1.print gets called.

But that's just happenstance; an implementation didn't have to do that. Undefined behavior is undefined, and you need to properly follow the Rule of 5. Or just use std::string.

Correct me if I'm wrong, I understand that I actually override the pointer address by creating a memory location on the heap. So, there is no point of the statement s = s + 1. — eet, Aug 29 '20 at 16:29
@eet: I dont' know what you mean by "override the pointer address by creating a memory location on the heap". But you are correct that `s = s + 1` accomplishes nothing; even if it was well-defined behavior (and it isn't, since `s` is an invalid pointer at this point), you're about to overwrite `s`. There's no point in changing the value of a variable that you're going to overwrite with something. — Nicol Bolas, Aug 29 '20 at 16:37

score 0 · Answer 2 · answered Aug 29 '20 at 16:08

The problem is that you called delete[] on the memory pointed by str1.

The runtime library is then allowed to reuse the same memory for the next allocation call and apparently this is what happened.

str1 didn't change the memory it pointed to, but the content changed.

Note that using a pointer to memory after it has been delete[]d is undefined behavior. So indeed anything can happen.

When you write classes that own heap allocated memory a lot of care should be taken about who owns the memory and when this memory is going to be released; in particular a lot of attention should go to copy constructor and assignment operator because the automatically generated code is rarely the correct one in case of memory owned using raw pointers.

score 0 · Answer 3 · answered Aug 29 '20 at 16:14

0

No, str1 and str2 do not point to the same memory location, before str2.change("StackOverFlowChanged") line. str2 is in a different location but with the same value as of str1. You can verify this using -

cout << &str1 << '\t' << &str2 << endl;

It will show that they have different locations in memory.

answered Aug 29 '20 at 16:14

Yashovardhan Singh

45
1
9

1

str1 and str2 dose not point to same memory but srt1.s and str2.s will!, try make all members as public and put `std::cout<(str1.s)<<"\t"<(str2.s)<<"\n";` – srilakshmikanthanp Aug 29 '20 at 16:27

C++ Object Copy

3 Answers3