Consider this function:
void useless() {
char data[] = "aaa";
}
From what I learned here, the "aaa" literal lives to the end of the program. However, the data[] (initialized by the literal) is local, so it lives only to the end of the function.
The memory is copied, so the program needs 4B for the literal, 4B for the data and sizeof(size_t) bytes for the pointer to data and sizeof(size_t) for the pointer of the literal - is this true?
If the literal has static storage duration, no new memory is allocated for the local literal by the second call - is this true?
char data[] = "aaa";
This is not a string literal but just an array. So there's no pointer there and memory is allocated only for the data.
If the literal has static storage duration, no new memory is allocated
for the local literal by the second call
This is true for string literals like: char *s="aaa"; From the standard:
2.13. Sttring literals
[...]An ordinary string literal has type “array of n const char” and static storage duration (3.7)
There is no pointer variable here. All there is an array, which is 4 bytes.
The compiler may or may not store the literal itself in memory; if it does, that is another 4 bytes.
Note that any memory taken up by anything other than the array itself is implementation-dependent.
I'm not sure what you mean by the "second call", but in general when you create an array, it takes up some amount of size... so if you create two arrays with the same literal, the compiler allocates space for two arrays (and perhaps -- or perhaps not -- for the literal also).
Related
Say I do this:
const char *myvar = NULL;
Then later
*myval = “hello”;
And then again:
*myval = “world”;
I’d like to understand what happens to the memory where “hello” was stored?
I understand it is in the read only stack space, but does that memory space stays there forever while running and no other process can use that memory space?
Thanks
Assuming you meant
myval = "world";
instead, then
I’d like to understand what happens to the memory where “hello” was stored?
Nothing.
You just modify the pointer itself to point to some other string literal.
And string literals in C programs are static fixed (non-modifiable) arrays of characters, with a life-time of the full programs. The assignment really makes the pointer point to the first element of such an array.
String literals have static storage duration. They are usually placed by the compiler in a stack pool. So string literals are created before the program will run.
In these statements
*myval = “hello”;
*myval = “world”;
the pointer myval is reassigned by addresses of first characters of these two string literals.
Pat attention to that you may not change string literals. Whether the equal string literals are stored as a one character array or different character arrays with the static storage duration depends on compiler options.
From the C Standard (6.4.5 String literals)
7 It is unspecified whether these arrays are distinct provided their
elements have the appropriate values. If the program attempts to
modify such an array, the behavior is undefined.
So will this code possibly cause a segfault because the pointer only is assigned the first memory address and the memory locations after it might outside of the usable range? Or will it allocate it by itself like an array of chars.
int main(){
char *final;
final = "This might cause a segfault. Especially if I am SUPPERRR LOOOOOOOOONNNNGG";
return 0;
}
Your use of the string literal is perfectly fine.
From the C++ Draft Standard (N3337):
2.14.5 String literals
8 Ordinary string literals and UTF-8 string literals are also referred to as narrow string literals. 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 (3.7).
...
12 Whether all string literals are distinct (that is, are stored in nonoverlapping objects) is implementation-defined. The effect of attempting to modify a string literal is undefined.
and
3.7.1 Static storage duration
1 All variables which do not have dynamic storage duration, do not have thread storage duration, and are not local have static storage duration. The storage for these entities shall last for the duration of the program
As long as you don't try to change the contents of the string literal through the pointer, there is no problem.
This question already has answers here:
Closed 10 years ago.
Possible Duplicate:
What is the difference between char a[] = “string” and char *p = “string”?
What is the difference between using memcpy on stack memory vs on heap memory?
The following code works on Tru64 but segfaults on LINUX
char * string2 = " ";
(void)memcpy((char *)(string2),(char *)("ALT=---,--"),(size_t)(10));
The second version works on LINUX
char * string2 = malloc(sizeof(char)*12);
(void)memcpy((char *)(string2),(char *)("ALT=---,--"),(size_t)(10));
Can someone explain the segfault on LINUX?
The first example has an Undefined Behavior. And so it might work correctly or not or show any random behavior.
Explanation:
The first example, declares a pointer string2to a string literal. String literals are stored in Implementation defined read only memory locations. A user program is not allowed to modify this memory. Any attempt to do so results in Undefined Behavior.
Reference:
C99 standard 6.4.5/5 "String Literals - Semantics":
In translation phase 7, a byte or code of value zero is appended to each multibyte character sequence that results from a string literal or literals. The multibyte character sequence is then used to initialize an array of static storage duration and length just sufficient to contain the sequence. For character string literals, the array elements have type char, and are initialized with the individual bytes of the multibyte character sequence; for wide string literals, the array elements have type wchar_t, and are initialized with the sequence of wide characters...
It is unspecified whether these arrays are distinct provided their elements have the appropriate values. If the program attempts to modify such an array, the behavior is undefined.
In the first example, you must differ between the pointer and the actual string contents: Although the pointer (string2) is on the stack, the actual string bytes are not. There is a good change that they are in the constants area which is readonly, hence the segfault.
First of all, the behavior is undefined. From C99, 6.4.5/6:
It is unspecified whether these arrays are distinct provided their
elements have the appropriate values. If the program attempts to
modify such an array, the behavior is undefined.
In practical terms, what happens is that the OS has chosen to load the associated image section in read-only memory; hence the segfault when you try to write.
In the first example you are not in stack memory but in .rodata (read-only data) section. String literals have static storage duration and are not required to be modifiable.
void foo(void)
{
// string array has automatic storage duration
char string[] = " ";
// string2 pointer has automatic storage duration and points to
// a string literal that a static storage duration
char *string2 = " "; // string2 pointer has
}
In the first case the destination for the memcpy is a string literal, as pointed out by others.
in the second case: Don't cast unnecessary. Avoid magic constants. Sizeof(char) == 1.
#include <stdlib.h>
#include <string.h>
char * string2 = malloc(1+strlen("ALT=---,--"));
(void)memcpy(string2, "ALT=---,--"), 1+strlen("ALT=---,--") );
, which is equivalent to:
char * string2 = malloc(1+strlen("ALT=---,--"));
(void)strcpy(string2, "ALT=---,--") );
BTW: In the original, the constant '10' was too small; the terminating nul byte would not be copied, and the string would be unterminated.
You can try this:
char string2[] = " ";
(void)memcpy((char *)string2,(char *)("ALT=---,--"),(size_t)(10));
Change your first example to:
char string2 [] = " ";
(void)memcpy((char *)(string2),(char *)("ALT=---,--"),(size_t)(10));
and then you'll be comparing stack memory versus heap memory.
Wouldn't the pointer returned by the following function be inaccessible?
char *foo(int rc)
{
switch (rc)
{
case 1:
return("one");
case 2:
return("two");
default:
return("whatever");
}
}
So the lifetime of a local variable in C/C++ is practically only within the function, right? Which means, after char* foo(int) terminates, the pointer it returns no longer means anything, right?
I'm a bit confused about the lifetime of a local variable. What is a good clarification?
Yes, the lifetime of a local variable is within the scope({,}) in which it is created.
Local variables have automatic or local storage. Automatic because they are automatically destroyed once the scope within which they are created ends.
However, What you have here is a string literal, which is allocated in an implementation-defined read-only memory. String literals are different from local variables and they remain alive throughout the program lifetime. They have static duration [Ref 1] lifetime.
A word of caution!
However, note that any attempt to modify the contents of a string literal is an undefined behavior (UB). User programs are not allowed to modify the contents of a string literal.
Hence, it is always encouraged to use a const while declaring a string literal.
const char*p = "string";
instead of,
char*p = "string";
In fact, in C++ it is deprecated to declare a string literal without the const though not in C. However, declaring a string literal with a const gives you the advantage that compilers would usually give you a warning in case you attempt to modify the string literal in the second case.
Sample program:
#include<string.h>
int main()
{
char *str1 = "string Literal";
const char *str2 = "string Literal";
char source[]="Sample string";
strcpy(str1,source); // No warning or error just Undefined Behavior
strcpy(str2,source); // Compiler issues a warning
return 0;
}
Output:
cc1: warnings being treated as errors
prog.c: In function ‘main’:
prog.c:9: error: passing argument 1 of ‘strcpy’ discards qualifiers from pointer target type
Notice the compiler warns for the second case, but not for the first.
To answer the question being asked by a couple of users here:
What is the deal with integral literals?
In other words, is the following code valid?
int *foo()
{
return &(2);
}
The answer is, no this code is not valid. It is ill-formed and will give a compiler error.
Something like:
prog.c:3: error: lvalue required as unary ‘&’ operand
String literals are l-values, i.e: You can take the address of a string literal, but cannot change its contents.
However, any other literals (int, float, char, etc.) are r-values (the C standard uses the term the value of an expression for these) and their address cannot be taken at all.
[Ref 1]C99 standard 6.4.5/5 "String Literals - Semantics":
In translation phase 7, a byte or code of value zero is appended to each multibyte character sequence that results from a string literal or literals. The multibyte character sequence is then used to initialize an array of static storage duration and length just sufficient to contain the sequence. For character string literals, the array elements have type char, and are initialized with the individual bytes of the multibyte character sequence; for wide string literals, the array elements have type wchar_t, and are initialized with the sequence of wide characters...
It is unspecified whether these arrays are distinct provided their elements have the appropriate values. If the program attempts to modify such an array, the behavior is undefined.
It's valid. String literals have static storage duration, so the pointer is not dangling.
For C, that is mandated in section 6.4.5, paragraph 6:
In translation phase 7, a byte or code of value zero is appended to each multibyte character sequence that results from a string literal or literals. The multibyte character sequence is then used to initialize an array of static storage duration and length just sufficient to contain the sequence.
And for C++ in section 2.14.5, paragraphs 8-11:
8 Ordinary string literals and UTF-8 string literals are also referred to as narrow string literals. 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 (3.7).
9 A string literal that begins with u, such as u"asdf", is a char16_t string literal. A char16_t string literal has type “array of n const char16_t”, where n is the size of the string as defined below; it has static storage duration and is initialized with the given characters. A single c-char may produce more than one char16_t character in the form of surrogate pairs.
10 A string literal that begins with U, such as U"asdf", is a char32_t string literal. A char32_t string literal has type “array of n const char32_t”, where n is the size of the string as defined below; it has static storage duration and is initialized with the given characters.
11 A string literal that begins with L, such as L"asdf", is a wide string literal. A wide string literal has type “array of n const wchar_t”, where n is the size of the string as defined below; it has static storage duration and is initialized with the given characters.
String literals are valid for the whole program (and are not allocated not the stack), so it will be valid.
Also, string literals are read-only, so (for good style) maybe you should change foo to const char *foo(int)
Yes, it is valid code, see case 1 below. You can safely return C strings from a function in at least these ways:
const char* to a string literal. It can't be modified and must not be freed by caller. It is rarely useful for the purpose of returning a default value, because of the freeing problem described below. It might make sense if you actually need to pass a function pointer somewhere, so you need a function returning a string..
char* or const char* to a static char buffer. It must not be freed by the caller. It can be modified (either by the caller if not const, or by the function returning it), but a function returning this can't (easily) have multiple buffers, so it is not (easily) threadsafe, and the caller may need to copy the returned value before calling the function again.
char* to a buffer allocated with malloc. It can be modified, but it must usually be explicitly freed by the caller and has the heap allocation overhead. strdup is of this type.
const char* or char* to a buffer, which was passed as an argument to the function (the returned pointer does not need to point to the first element of argument buffer). It leaves responsibility of buffer/memory management to the caller. Many standard string functions are of this type.
One problem is, mixing these in one function can get complicated. The caller needs to know how it should handle the returned pointer, how long it is valid, and if caller should free it, and there's no (nice) way of determining that at runtime. So you can't, for example, have a function, which sometimes returns a pointer to a heap-allocated buffer which caller needs to free, and sometimes a pointer to a default value from string literal, which caller must not free.
Good question. In general, you would be right, but your example is the exception. The compiler statically allocates global memory for a string literal. Therefore, the address returned by your function is valid.
That this is so is a rather convenient feature of C, isn't it? It allows a function to return a precomposed message without forcing the programmer to worry about the memory in which the message is stored.
See also #asaelr's correct observation re const.
Local variables are only valid within the scope they're declared, however you don't declare any local variables in that function.
It's perfectly valid to return a pointer to a string literal from a function, as a string literal exists throughout the entire execution of the program, just as a static or a global variable would.
If you're worrying about what you're doing might be invalid undefined, you should turn up your compiler warnings to see if there is in fact anything you're doing wrong.
str will never be a dangling pointer, because it points to a static address where string literals resides.
It will be mostly read-only and global to the program when it will be loaded.
Even if you try to free or modify, it will throw a segmentation fault on platforms with memory protection.
A local variable is allocated on the stack. After the function finishes, the variable goes out of scope and is no longer accessible in the code. However, if you have a global (or simply - not yet out of scope) pointer that you assigned to point to that variable, it will point to the place in the stack where that variable was. It could be a value used by another function, or a meaningless value.
In the above example shown by you, you are actually returning the allocated pointers to whatever function that calls the above. So it would not become a local pointer. And moreover, for the pointers that are needed to be returned, memory is allocated in the global segment.
I'm a little bit confused about this expression:
char *s = "abc";
Does the string literal get created on the stack?
I know that this expression
char *s = (char *)malloc(10 * sizeof(char));
allocates memory on the heap and this expression
char s[] = "abc";
allocates memory on the stack, but I'm totally unsure what the first expression does.
Typically, the string literal "abc" is stored in a read only part of the executable. The pointer s would be created on the stack(or placed in a register, or just optimized away) - and point to that string literal which lives "elsewhere".
"abc"
String literals are stored in the __TEXT,__cstring (or rodata or whatever depends on the object format) section of your program, if string pooling is enabled. That means, it's neither on the stack, nor in the heap, but sticks in the read-only memory region near your code.
char *s = "abc";
This statement will be assign the memory location of the string literal "abc" to s, i.e. s points to a read-only memory region.
"Stacks" and "heaps" are implementation details and depend on the platform (all the world is not x86). From the language POV, what matters is storage class and extent.
String literals have static extent; storage for them is allocated at program startup and held until the program terminates. It is also assumed that string literals cannot be modified (attempting to do so invokes undefined behavior). Contrast this with local, block-scope (auto) variables, whose storage is allocated on block entry and released on block exit. Typically, this means that string literals are not stored in the same memory as block-scope variables.