CODEWITHSUNDEEP
c++
eet
eet

Reputation: 135

C++ Object Copy

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?

Upvotes: 1

Views: 125

Answers (3)

Yashovardhan Singh
Yashovardhan Singh

Reputation: 43

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.

Upvotes: 0

Nicol Bolas
Nicol Bolas

Reputation: 473232

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.

Upvotes: 1

6502
6502

Reputation: 114461

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.

Upvotes: 0

Related Questions