C++ management of strings allocated by a literal

Question

Do I need to take care of memory allocation, scope and deletion of C++ strings allocated by a literal?

For example:

<         


        

Answer 1

• func1() returns a pointer to a string literal. You must not delete string literals.
• func2() (presumably, you omitted the std:: prefix) returns a std::string. It takes care of itself.
• func3() returns a pointer to a string that's managed by a std::string object that's destroyed when the function exits. You must not touch that pointer after the function returns.

• You would have to take care of the memory returned by this function:

  const char* func4() {
     char* s = new char[100];
     // fill char array with a string
     return s;
  }
  

However, manual resource management is tricky. For starters, if a function returns a naked pointer, you don't know whether it points to one objects (char) or an array thereof and whether you need to delete it. You should avoid all that and just stick to std::string.

Answer 2

In func3 your string local is created by the compiler calling the implicit constructor string(const char*) initializing its internal buffer with a copy of the string literal. You then return a pointer to the internal buffer of the string which promptly goes out of scope and gets freed as soon as the function returns.

Answer 3

You have a different problem with s3, namely that the function func3() returns a pointer into an object that goes out of scope when the function returns. Don't.

To clarify: Your local string object within func3() will cease to exist on return of the function, so no need to delete. However, you still have a pointer to its internal buffer, which you return. You can't use that.

Very good and detailed past answer here, lest more confusion ensues: Is it more efficient to return a const reference

Answer 4

I snip the relevant code to each function and treatment of its return value, and comment below:

const char* func1() {
   const char* s = "this is a literal string";
   return s;
}
const char*  s1 = func1();
delete s1; //?

You can't delete s1, as the string it points to does not live on the heap.

string func2() {
   string s = "this is a literal string";
   return s;
}
string s2 = func2();

This is fine. func2's s goes out of scope and cleans up. s2 will duplicate the string from s, and also clean itself up at the end of func.

const char* func3() {
   string s = "this is a literal string";
   return s.c_str();
}
const char*  s3 = func3();
delete s3; //?

func3 returns a pointer to a string that has been freed. You will get a double free exception upon execution of delete s3.