operator overloading

[arjita07]

This is the program for performing concatenation using overloading + operator. The problem with the code is it is not printing concatenated string.

#include<cstring>
#include<iostream>
using namespace std;
class mystring
{
char *str;
int size;
public:
mystring()
{
str=NULL; size=0;
}
mystring(mystring &a)
{
size=a.size;
str=new char[size+1];
strcpy(str,a.str);
}

mystring(char *s)
{

size=strlen(s);
str=new char[size+1];
strcpy(str,s);
}
friend mystring operator+(mystring &,mystring &);

void display();
~mystring()

{ this->display();
delete []str;
}


}t;
mystring operator+(mystring &a,mystring &b)
{


t.size=a.size+b.size;
t.str=new char[t.size+1];
strcpy(t.str,a.str);
strcat(t.str,b.str);
return t;
}
void mystring::display()
{
cout<<str;
}
int main()
{
char s[100]={NULL};
cout<<"\n ENTER STRING 1: ";
cin>>s;
mystring s1(s);
cout<<"\n ENTER STRING 2: ";
cin>>s;
mystring s2(s);

s1=s1+s2;
cout<<"\n CONCATINATING STRING : ";
s1.display();
cout<<endl;

}
A sample run to this problem is as below:


SAMPLE OUTPUT
ENTER STRING 1: xyz

ENTER STRING 2: abc

CONCATINATING STRING :


On running the gdb session I found that t (of mystring variable class) is destructed by after the operator +() function (before returning back to main) and therfore no value s1 is being printed. I can not understand why for t variable destructor is called even though it has global scope.

Please suggest the corrective solution for the same.

[Rishi Rai]

you need to overload assign operator as well.

#include<cstring>
#include<iostream>

using namespace std;

class mystring
{
char *str;
int size;
public:
mystring()
{
str=NULL; size=0;
}
mystring(const mystring &a)
{
size=a.size;
str=new char[size+1];
strcpy(str,a.str);
}

mystring& operator=( const mystring &rhs)
{
if (this==&rhs)
return *this;

size=rhs.size;
str=new char[size+1];
strcpy(str,rhs.str);
return *this;
}
mystring(char *s)
{

size=strlen(s);
str=new char[size+1];
strcpy(str,s);
}
friend mystring operator+(const mystring &,const mystring &);

void display();
~mystring()

{ this->display();
delete []str;
}


}t;

mystring operator+(const mystring &a,const mystring &b)
{

//mystring t1;
t.size=a.size+b.size;
t.str=new char[t.size+1];
strcpy(t.str,a.str);
strcat(t.str,b.str);
return t;
}
void mystring::display()
{
cout<<str;
}
int main()
{
char s[100];
memset(s, '\0', sizeof(s));
cout<<"\n ENTER STRING 1: ";
cin>>s;
mystring s1(s);
cout<<"\n ENTER STRING 2: ";
cin>>s;
mystring s2(s);
//mystring s3;
s1=s1+s2;
cout<<"\n CONCATINATING STRING : ";
s1.display();
cout<<endl;

}

[arjita07]

what u suggested worked perfectly fine but can u plz tel me why are we passing arguments by reference to operator+ and operator=,
why following statements didn't work:
operator+(mystring a,mystring b); why should we use const...??

[Rishi Rai]

operator+(mystring a,mystring b); should also work, it good practice to pass parameter as const reference if we are not modifying its value in side the function.

[andywestken]

it good practice to pass parameter as const reference if we are not modifying its value in side the function.

For non-native types. Passing int, double, etc by const ref is a bit pointless.

A ref is like a pointer, in that you are passing the address of the variable. So the trade off is between the cost of copying the data (if you pass by value) against a pointer deref (if you pass by ref).

For 32 bit systems, the size of a pointer is the same as an int. So it is actually a little bit slower to pass an int by ref, as you are copying exactly the same ammount of data (a 32-bit int or a 32-bit pointer to the same int).

While I usually pass std::string by const ref, really tiny structs (like a 2D point class, which is the size of 2 ints) I generally pass by value. As I do long long/__int64 parameters.

[Rishi Rai]

thank you andywestken to elaborate on this.

[arjita07]

thanks both of u for helping me out.... :)