Is there a memory leakage in this simple code snippet

does strdup cause memory leakage?

Code:

---

    string str("/usr/bin/");                                                                                                                                               
    string str2 = string(dirname(strdup(str.c_str())));                                                                                                                   
    cout<<str2<<endl;

---

I modified the code as:

Code:

---

    string str("/usr/bin/");                                   
    char * tmp = strdup(str.c_str());                                                                                                                                       
    string str2 = string(dirname( tmp ));                                                                                                                                   
    delete(tmp);

---

Using valgrind it reports:

Quote:

---

==18859== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 17 from 1)
==18859== malloc/free: in use at exit: 0 bytes in 0 blocks.
==18859== malloc/free: 3 allocs, 3 frees, 49 bytes allocated.
==18859== For counts of detected errors, rerun with: -v
==18859== No malloc'd blocks -- no leaks are possible.

---

try 'string(dirname( *tmp ));' instead ?

strdup is nonstandard, I think, and use free, not delete.

The first example is a memory leak, as you never free the result of strdup.

In the second code-snippet, strdup uses malloc, so you should use free to free that memory.

Also, there is absolutely no need to copy the string with strdup before calling dirname, as dirname has a local static variable that it returns as the result - and std::string will copy the string itself. However, If you are using multiple threads that may call dirname, you will need to make sure that the result from dirname is copied whilst in a lock situation.

--
Mats

No, as a matter of fact, you have to use strdup here.
If your code is:

Code:

---

string str2 = string(dirname(str.c_str()));

---

You will get errors from compiler:

Quote:

---

main.cc: In function `int main(int, char**)':
main.cc:25: error: invalid conversion from `const char*' to `char*'

---

Quote:

---

Originally Posted by matsp

The first example is a memory leak, as you never free the result of strdup.

In the second code-snippet, strdup uses malloc, so you should use free to free that memory.

Also, there is absolutely no need to copy the string with strdup before calling dirname, as dirname has a local static variable that it returns as the result - and std::string will copy the string itself. However, If you are using multiple threads that may call dirname, you will need to make sure that the result from dirname is copied whilst in a lock situation.

--
Mats

---

Perhaps you could use this to avoid worrying about the free/delete:

Code:

---

    string str("/usr/bin/");
    string str2 = string(dirname( &(std::vector<char>(str.begin(), str.end()))[0] ));

---

How about just

Code:

---

string str2 = string( const_cast<char*>(dirname( str.c_str() )) );

---

EDIT: Bad suggestion.

Quote:

---

Originally Posted by Elysia

How about just

Code:

---

string str2 = string( const_cast<char*>(dirname( str.c_str() )) );

---

---

No, dirname() is actually allowed to modify the parameter, not just legacy const-incorrect.

Elysia, I do not think your example is correct, since the const_cast is applied to the return value of dirname(), but of course there is no need to do that. The const_cast should be applied to the argument to dirname(), but then the assumption is that dirname() does not modify its argument.

I need a prototype for dirname, since obviously std::string should be able to accept any string passed to it.
Dang. No prototype for dirname >_<
Then it's beyond me why you have to use such pesky workarounds.

Quote:

---

I need a prototype for dirname, since obviously std::string should be able to accept any string passed to it.
Dang. No prototype for dirname >_<

---

RTFM: dirname :)

Funny how just useless results showed up on google...
But I see the problem.
OK, so wouldn't this work then?

Code:

---

    string str("/usr/bin/");
    string str2 = std::string( dirname(&str.begin()[0]) );

---

Quote:

---

OK, so wouldn't this work then?

---

No, you're not allowed to rely on &str[0] or even &str.begin()[0] being continuous memory, or being in a plain format that is safe to modify.

Quote:

---

Funny how just useless results showed up on google...

---

When I typed "man dirname", laserlight's suggestion was the first result.
When I typed just "dirname", the third result was the specification of dirname from the OpenGroup. (They don't actually spell it out that the function may modify the input.)

Naturally the stupid std::string doesn't even have a function to access its buffer without a lot of hacks or workarounds.
So much for flexibility of the standard library.

It's a rule that's there so that the implementors have flexibility.