Constructor and desstructor problem

[Sweeya]

/*Program to do manipulations on a string*/

#include <iostream>
using namespace std;

class String
{
int len;
char *p;

public:
String ()
{
cout << "default constructor " << this << endl;
len = 0;
p = NULL;
}
String (const char *s)
{
cout << "String constructor called " << s << endl;
len = strlen(s);
p = new char[len + 1];
strcpy(p, s);
}
String (const String &s)
{
cout << "Copy constructor invoked " << s.p << endl;;
len = s.len;
p = new char[len + 1];
strcpy(p, s.p);
}
~String ()
{
cout << "deleting " << p << " " << this << endl;
delete p;
}
void display(void)
{
cout << p << "\t address of p = " << &p << "\tobject this = " << this << endl;
}
// friend String operator + (const String &s, const String &t);
String operator + (const String &t);
friend int operator <= (const String &s, const String &t);
friend void show (const String &s);
};

String String :: operator + (const String &t)
{
String temp;
cout << "Entered operator+() " << &temp << endl;

temp.len = len + t.len;
temp.p = new char[temp.len + 1];
strcpy(temp.p, p);
strcat(temp.p, t.p);

temp.display();
cout << "Exiting operator+() " << &temp << endl;
return temp;
}

void show (const String &s)
{
cout << s.p;
}

main()
{
String s1("Sidharth") , s2("Sweeya ");
String s3;

//String s3 = s2 + s1;
s3 = s2 + s1;

s1.display();
s2.display();
s3.display();

return 0;
}



Output of the program:

String constructor called Sidharth
String constructor called Sweeya
default constructor 0xbff06c50
default constructor 0xbff06c40
Entered operator+() 0xbff06c40
Sweeya Sidharth address of p = 0xbff06c44 object this = 0xbff06c40
Exiting operator+() 0xbff06c40
deleting Sweeya Sidharth 0xbff06c40
Sidharth address of p = 0xbff06c74 object this = 0xbff06c70
Sweeya address of p = 0xbff06c64 object this = 0xbff06c60
address of p = 0xbff06c54 object this = 0xbff06c50
deleting 0xbff06c50
*** glibc detected *** double free or corruption (fasttop): 0x09e83028 ***
Aborted (core dumped)




If I change the code in the main to
main()
{
String s1("Sidharth") , s2("Sweeya ");
//String s3;

String s3 = s2 + s1;
//s3 = s2 + s1;

s1.display();
s2.display();
s3.display();

return 0;
}


Ouput:

String constructor called Sidharth
String constructor called Sweeya
default constructor 0xbffab2b0
Entered operator+() 0xbffab2b0
Sweeya Sidharth address of p = 0xbffab2b4 object this = 0xbffab2b0
Exiting operator+() 0xbffab2b0
Sidharth address of p = 0xbffab2d4 object this = 0xbffab2d0
Sweeya address of p = 0xbffab2c4 object this = 0xbffab2c0
Sweeya Sidharth address of p = 0xbffab2b4 object this = 0xbffab2b0
deleting Sweeya Sidharth 0xbffab2b0
deleting Sweeya 0xbffab2c0
deleting Sidharth 0xbffab2d0



In the first case the destructor is being called for the temp variable in the operator + function. But in the second case why is not called?

In the second case if copy constructor have been invoked then p should be pointing to a diff location. why does String s3 = s2+ s1 does not invoke a copy constructor?


Please help me

[svlsr2000]

In your function operator +, your returning "pass by value", this result in deletion of your object as soon as your function returns.

[Sweeya]

I understand that. But why is the destructor not being called in the second case?

i mean when i say

String S3 = S1 + S2;

[Sweeya]

I thought when you say

String S3 = S2 + S1

A copy constructor will be invoked for S3 and a destructor will be invoked for the temp obj in the operator + function

[svlsr2000]

Can you check how your deleting the array once.

[Sweeya]

I am sorry but i did not understand what you said.

[svlsr2000]

arrays needs to deleted using delete[]ptr. But your trying to delete using delete ptr

[Sweeya]

Hi,
I tried deleting using delete []p. But the the output is still the same

[svlsr2000]

can you overload = and see once, cause i am using
string s3(s1+s2) and it works well

[weaknessforcats]

Everyone is on the wrong track.

The constructors are fine, the destructors are fine and everything is being called at the right time. The delete [] is a red herring since you don't need that on arrays of built-in types.

What is missing is the assignment operator.

All S3 = S2 + S1 does is assign the char* returned from operator+ to S3. Then the destrcutor for temp is called and deletes the string held by S3.

Remember the Rule of the Big Three: Whenever you write a copy constructor, destructor or assignment operator, you must write all three.