Re: Code Help
On Feb 28, 12:32 am, "Alf P. Steinbach" <al...@start.no> wrote:
* aaronWbry...@gmail.com:
[...]
MyString MyString :: operator =(const MyString& s)
Uhuh -- that result type should be a reference.
{
delete [] data;
size = s.size;
capacity = size + 1;
data = new char[capacity];
If this throws you're screwed, having already changed size and
capacity.
And deleted data! If the new throws, presumably, he'll delete
it again in the destructor, which could be worse than having an
irrelevant size and capacity.
And of course, if he happens to assign an object to itself, he's
also deleted his source data.
while (size >= capacity)
{
grow();
}
This loop body will never execute.
strcpy(data, s.data);
data[size + 1] = '\0';
return *this;
}
The default way to implement operator= is
void MyString::swap( MyString& other ) throw()
{
std::swap( size, other.size );
std::swap( capacity, other.capacity );
std::swap( data, other.data );
}
MyString& MyString::operator=( MyString other )
{
swap( other ); return *this;
}
That's one variant. It's probably preferable to avoid the value
parameter at the interface level---it "reveals" something of the
internal workings. But there are worse sins.
[...]
MyString MyString :: operator + (const MyString& s) const
{
char *addition;
addition = new char[strlen(data) + strlen(s.data)];
strcpy(addition, strcat(data, s.data));
Uh oh.
Yes. We could probably start a small contest: how many things
are wrong with the two preceding lines. (strcat on an
uninitialized array, strcat called before strcpy, not allocating
enough memory...)
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34