在构造函数中初始化const char * - 会有内存泄漏吗？

Question

Here is the code which I got:

struct ChoiceLine
{
    const char *prompt;
    ChoiceLine(const char *pr):
        prompt(pr)   //can this cause a memory leak?
    {
        ;
    }
};

...

ChoiceLine choiceLine("hello world");

So is it OK to initialize a const char* with another const char* ?

PS: I know about std::string , which unfortunately does not fit my purposes.

Answer 1

There is no dynamic memory allocation, so there is no memory leak. Your data member just points to a string literal. It is the equivalent of doing this:

const char* c = "Hello, World!";

Answer 2

Yes that's fine if a little unsafe: the memory associated with prompt is not owned by the class instance.

(In your particular case ChoiceLine choiceLine("hello world"); all will be well since the string literal will last the life of the program).

Hence it would have to be kept in scope for as long as the class instance was in scope.

If I were you I'd use a std::string as your class member and suffer a deep copy.

Answer 3

No there's no memory leak, because nothing is being dynamically allocated.

The space required for 'prompt' is just a pointer, and that's effectively allocated by the compiler.

Answer 4

No memory leak. Untill you allocate some memory dynamically.

Answer 5

It depends on why you cannot use std::string , and what your class is supposed to do. As you've written it, it basically leaves the memory management to the caller; typically, such classes are used when the only reasonable arguments would be string literals (which have static lifetime). In other contexts, I've used such classes to manage pointers to strings (or other things) returned by libraries using a C interface; in such cases, the whole purpose of the class is to free the string in its destructor (often by calling a specific function in the library interface, rather than delete[] or free ).

The names in your example suggest that you are in the first case: a prompt is almost certainly a string literal or a string looked up in a dictionary with static lifetime (for internationalization purposes); in either case, it would be an error to attempt to delete or free it.