Re: overloaded assignment operator and copy constructor.
On Aug 25, 12:19 am, alexdem...@gmail.com wrote:
MyType& operator=( MyType const& other )
{
MyType temporary( other ); // Copy construct into new instance.
swap( other ); // Swap contents with new instance.
Sorry, I cannot understand what does it mean swap?
For example, while cannot we do:
MyType& operator=(MyType const& other)
{
swap(other);
return *this;
}
Please, can you describe (for example) such situation:
class MyClass
{
int* pArray; /pointer to array, need allocation memory
/...
}
what's copy constructor, operator= and swap?
The term 'swap' means exchanging the values of two objects.A general
solution for swappig two objects is the famuse triple assign method:
temp=other;
other=me;
me=temp;
but in some cases there exists a short cut and we do not need to pay
that much for the swap;In such cases a swap is normally performed much
faster and easier than an assignment ,and assignment is defined in
terms of swap rather than the vice versa.(pointeroids , string &
reference counting are best examples .):
struct my_string{
public:
my_string():str(null),sz(0){};
my_string(const char *const s){/* build from null-terminated c-
style string and literals*/
sz=strlen(s);
str=new char[sz];
memcpy(str,s,sz);
};
my_string(my_string& s):str(new char[s.sz]),sz(s.sz)
{memcpy(str,s.str,sz);};
bool swap(my_string& right){
if (right==*this) return false;
//swap str:
char* temp=str;
str=right.str;
right.str=temp;
//swap sz:
sz^=right.sz;
right.sz^=sz;
sz^=right.sz;
return true;
};
bool operator==(const my_string& right){
if(sz!=right.sz) return false;
return 0==memcmp(str,right.str,sz);
};
const my_string& operator=(my_string other){
swap(other);
return *this;
};
~my_string(){delete[] str;};
private:
char* str;
size_t sz;
....//concate , find , cstr , size ... etc
};
this is not the best approach to design strings but it shares the
common swap/copy/assign method of dynamic memory management with
better solutions.If you defined swap in terms of assignment,allocation/
deallocation(new/delete) of memory would happen three times per
swap.But now swap needs no allocation/deallocation and as you can
see,assignment needs exert a deallocation in either case (destruction
of auto variable or explicit delete).
regards,
FM