Returning pointer to string literal?

[Gorgor]

Is the following valid?

   const char* someFunction( void )
   {
      return "some string";
   }

Isn't the string created on the stack, and thus evaporates when the function exits, and thus the pointer is invalid? Wouldn't it be wrong to rely on it being created in some theoretcical "read only" space where it has functionally static time scope?

[Siddhartha]

Is the following valid?

    const char* someFunction( void )
    {
       return "some string";
    }

Isn't the string created on the stack, and thus evaporates when the function exits, and thus the pointer is invalid? Wouldn't it be wrong to rely on it being created in some theoretcical "read only" space where it has functionally static time scope?

It is valid, because the string is not created on your function stack.

It belongs to the Application Stack.

Read a similar thread here.

[RoboTact]

An ordinary string literal has type "array of n const
char" and static storage duration (_basic.stc_), where n is the size
of the string as defined below, and is initialized with the given
characters.

____________________________

[ahoodin]

I think it is wrong in this manner:

A literal is a char[] not a char *, so your returning the address of a literal, not a real pointer.

This code fails on MSVC 6.0:

const char* someFunction( void )
{
   const char cmsg[16] = "Some String\n";
   return cmsg;
}

as it should, because cmsg goes out of scope....

But frighteningly enough this code does not:

const char* someFunction( void )
{
   const char *cmsg = "Some String\n";
   return cmsg;//"some string";
}

Neither does this code:

const char* someFunction( void )
{
   const char cmsg[16] = "Some String\n";
   return "some string";
}

But you have to keep in mind, returning a literal string is the prob the least progressive coding style on the planet.

ahoodin

[cilu]

A literal is a char[] not a char *, so your returning the address of a literal, not a real pointer.

A pointer is an address...

[NMTop40]

MSVC 6.0 is acting correctly here.

const char* someFunction( void )
{
   const char cmsg[16] = "Some String\n";
   return cmsg;
}

When you declare your array that way it is local, and it initialises the array by copying the string into it. That you have declared it as const is relevant only in that you cannot modify it within the scope of the function. You are therefore returning the address of a local variable.

const char* someFunction( void )
{
   const char *cmsg = "Some String\n";
   return cmsg;//"some string";
}

This is different now as it does not copy the literal anywhere but simply gets cmsg to point to its location in the static application space. When it returns the pointer, it is still pointing to the same memory and is still valid.

const char* someFunction( void )
{
   const char cmsg[16] = "Some String\n";
   return "Some String\n";
}

Even with me now modifying your return to make it return exactly the same string as the line above, this is OK. cmsg goes out of scope but that is not what your function is returning. Your compiler may decide to create two different strings with the value "Some String\n" or it may be clever and create only one copy, but either way, your function will actually return a pointer to where it decides to store the second one (which may or may not be the first).

[ahoodin]

Conceptually you are right, however syntatically you are wrong. Otherwise I could write this:

*&0x0041f01c = 100;

and not get this:

C:\projects\literaltest\literaltest.cpp(11) : error C2101: '&' on constant
C:\projects\literaltest\literaltest.cpp(11) : error C2100: illegal indirection
C:\projects\literaltest\literaltest.cpp(11) : error C2106: '=' : left operand must be l-value

A pointer is a variable that contains a memory address.

It can be dereferenced with the asterisk.

ahoodin

[ahoodin]

MSVC 6.0 is acting correctly here.

const char* someFunction( void )
{
   const char cmsg[16] = "Some String\n";
   return cmsg;
}

When you declare your array that way it is local, and it initialises the array by copying the string into it. That you have declared it as const is relevant only in that you cannot modify it within the scope of the function. You are therefore returning the address of a local variable.

const char* someFunction( void )
{
   const char *cmsg = "Some String\n";
   return cmsg;//"some string";
}

This is different now as it does not copy the literal anywhere but simply gets cmsg to point to its location in the static application space. When it returns the pointer, it is still pointing to the same memory and is still valid.

const char* someFunction( void )
{
   const char cmsg[16] = "Some String\n";
   return "Some String\n";
}

Even with me now modifying your return to make it return exactly the same string as the line above, this is OK. cmsg goes out of scope but that is not what your function is returning. Your compiler may decide to create two different strings with the value "Some String\n" or it may be clever and create only one copy, but either way, your function will actually return a pointer to where it decides to store the second one (which may or may not be the first).

I see so the function actually returns the pointer.

ahoodin

[RoboTact]

Conceptually you are right, however syntatically you are wrong. Otherwise I could write this:

*&0x0041f01c = 100;

Note that your counterexample is incorrect: 0x0041f01c is neither pointer nor address: it's just an integer. However, you can do the same using correct type:

*((int*)(void*)0x0041f01c) = 100;

[ahoodin]

But your casting it to be a pointer, which makes you cheating!

ahoodin

[NMTop40]

This would be illegal (I assume)

const int * x = &100;

This would be legal:

const int * x = { 100 };

And the {100} would be stored in a similar way to strings. In fact a string literal "String\n" is no more than a short-hand for

{ 'S', 't', 'r', 'i', 'n', 'g', '\n', '\0' }

This would return an invalid pointer:

const int * a()
{
   const int x = 100;
   return &x;
}

This would return a valid pointer (I presume)

const int * a()
{
   const int * x = { 100 };
   return x;
}

So would this:

const int * a()
{
   return {100};
}

This would fail (would compile but return auto-pointer)

const int * a()
{
   const int x[] = {100};
   return x;
}