Re: Does this constitute a memory leak?
Nikola schrieb:
Thomas J. Gritzan wrote:
When you do
c = func3();
you call the copy assignment operator, but you didn't define it, so the
compiler supplied copy assignment operator is used.
The copy assignment operator usually looks like this:
tst& operator=(const tst& rhs)
{
tst temp(rhs); // copy and...
std::swap(a, temp.a); // ...swap
return *this;
}
While your string class has to use new[] internally, the client code
shouldn't use new at all.
tst func3()
{
tst a("3456");
return a; // <---- Copy constructor is called
}
Actually, it isn't. In the following example:
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
class tst {
public:
char *a;
tst() {
printf("Default constructor.\n");
a = new char[1];
a[0] = 0;
}
tst(const char *b) {
printf("Construct from char * \"%s\".\n", b);
a = new char[strlen(b)];
strcpy(a, b);
You don't allocate enough memory. Buffer overflow when strcpy copies the
null terminator.
}
tst(const tst ©) {
printf("Copy constructor for \"%s\".\n", copy.a);
a = new char[strlen(copy.a)];
strcpy(a, copy.a);
As above.
}
~tst() {
printf("Destructor for \"%s\".\n", this->a);
delete [] a;
a = NULL;
You don't need to assign NULL. It's the destructor. The member variable
'a' won't exist after this.
}
tst &operator=(const char *Value) {
printf("String = const char *: ");
printf("Replacing \"%s\" with \"%s\".\n", a, Value);
if (a != NULL) delete [] a;
You don't need to check for NULL, since delete[] also does it.
a = new char[strlen(Value) + 1];
strcpy(a, Value);
return *this;
}
You can use the copy & swap idiom for this function, too:
tst temp(Value);
std::swap(a, temp.a);
return *this;
}
tst &operator=(tst Value) {
Here you pass by value. A copy is made from the assigned value.
printf("String = String: ");
if (a != NULL) printf("Replacing \"%s\" with \"%s\".\n", a, Value.a);
else printf("Assigning \"%s\".\n", Value.a);
tst temp(Value);
Here you copy again. Makes two copies. One of the copies would be enough.
When you consult the answer of Kai-Uwe, he wrote this function:
tst & operator= ( tst lhs ) {
std::swap( a, lhs.a );
return ( *this );
}
It makes a copy in the parameter list, but only a swap in the function
body. My version (at the start of this posting) uses pass by reference
and makes the copy explicit in the function body.
Both versions are equivalent, so you can use either, but please avoid
the double copy.
std::swap(a, temp.a);
return *this;
}
};
tst func1() {
printf("FUNC1\n");
tst a("1234");
return a;
}
int main(void) {
{
tst d = func1();
printf("--\n");
tst e = "";
printf("--\n");
e = func1();
printf("--\n");
}
printf("Done\n");
return 0;
}
This is the output:
FUNC1
Construct from char * "1234".
--
[...]
As you can see, the copy constructor is not called when returning from
func1().
The compiler is allowed to optimize away copy constructor calls.
It usually will when it applies the so called NRVO (named return value
optimization).
I assume this class is for learning purposes. You should use std::string
for storing strings, unless you have a good reason not to.
--
Thomas