在堆上分配C样式的字符串

Question

guys, I need a little technical help. I'm working in C++, don't have much experience working in it but know the language somewhat. I need to use a C-style string (char array) but I need to allocate it on the heap.

If you look at this very simple piece of code:

#include <iostream>
using namespace std;

char* getText()
{
    return "Hello";
}

int main()
{
    char* text;
    text = getText();
    cout << text;
    //delete text; // Calling delete results in an error
}

Now, I'm assuming that the "Hello" string is allocated on the stack, within getText(), which means the pointer will be "floating" as soon as getText returns, am I right?

If I'm right, then what's the best way to put "Hello" on the heap so I can use that string outside of getText and call delete on the pointer if I need to?

Answer 1

No, there's no hidden stack allocation going on there. "Hello" is static data, and ends up in the .data segment of your program.

This also means the string is shared for all calls to getText . A common use when this would be acceptable is if you have a large list of error messages that map to error codes. Functions like strerror work like this, so that you can get descriptive error messages for standard library error codes. But nobody is supposed to modify the return value of strerror (also because it is const ). In your case, your function definition should read:

const char *getText()

If you do want a private copy of the string returned, you can use the strdup function to make a copy:

return strdup("Hello");

Answer 2

This is not right. "Hello" is a static string constant and it really should be const char*.

Answer 3

Use a std::string , from the <string> header. Then use its .c_str() member function. Then you don't have to care about allocation and deallocation: it takes care of it for you, correctly.

Cheers & hth.,

Answer 4

A narrow string literal has type "array of n const char ", where n is the size of the string as defined below, and has static storage duration .

Static storage is neither automatic ("on the stack") nor dynamic ("on the heap"). It is allocated prior to the actual runtime of your program, so pointers to string literals never become invalid.

Note that char* p = "Hello" is deprecated because it is dangerous: the type system cannot prevent you from trying to change the string literal through p (which would result in undefined behavior ). Use const char* p = "Hello" instead.