C memory question

Question

char buffer[10];
strcat(buffer, "hi");
printf("%s", buffer);

In the above code, it prints some weird symbol or number followed by the "hi", I know strcat is appending to buffer. And I normally zero the memory in buffer. But i'm curious why I usually have to do that.

If i do printf("%i", buffer); without the strcat, it just prints a random number. What is that number? Could anyone explain or link to a tut that explains what is in buffer, before I fill it with anything?

That random number is whatever arbitrary junk that happens to be residing in the memory at the location of the char buffer at the time you created it. — Robert Harvey, Aug 22 '11 at 16:42

jman · Accepted Answer · 2011-08-22T18:02:30.247

"buffer" is a 10 byte region on the stack, and it'd contain whatever was last written to that region of memory. When you strcat, it would concatenate "hi" after the first null byte in that region (So if the first null byte is beyond 10 bytes, you'd overwrite something on the stack). When you print without zeroing, it'd print the bytes until the first 0 (null). Again, this might print beyond the 10 bytes.

When you printf (%I, buffer), you print the address of that location.

cnicutar · Answer 2 · 2011-08-22T18:53:59.103

3

First up, you need to zero-init the buffer:

char buffer[10] = {0};
buffer[0] = 0; /* As R.. points out, initializing all elements is excessive. */

Second, the number is the address of buffer, as a decimal. If you really want to print that, you are better off printing:

printf("%p\n", buffer);

edited Aug 22 '11 at 18:53

answered Aug 22 '11 at 16:40

cnicutar

178,505
25
365
392

that type of initialization doesn't work in C, only C++ AFAIK – Vinicius Kamakura Aug 22 '11 at 16:43
1

@hexa Check again :-) It's valid in C89 and everything after. – cnicutar Aug 22 '11 at 16:48
`{0}` works to zero-initialize **any type**, but here it's equivalent to using `""` and probably the latter would be less confusing to most readers I think... – R.. GitHub STOP HELPING ICE Aug 22 '11 at 17:51
Also note that, *either way*, it initialized the *whole* array with zeros. For large buffers that may be undesirable/a waste of time. Therefore it's often preferred to leave the array uninitialized and simply write `buffer[0]=0;` after the initialization. – R.. GitHub STOP HELPING ICE Aug 22 '11 at 17:53
@R.. Didn't think about the performance implications, it's quite sensible :-) – cnicutar Aug 22 '11 at 18:44

score 2 · Answer 3 · answered Aug 22 '11 at 16:41

2

You need a terminating '\0' to mark the end of the string, use

strcpy(buffer,"hi");

strcat() tries to append to an already existing string which is assumed to be '\0' terminated. Your buffer isn't initialized.

answered Aug 22 '11 at 16:41

stacker

68,052
28
140
210

score 1 · Answer 4 · answered Aug 22 '11 at 16:42

1

do a memset(buffer, 0, 10) to zero the memory first, before appending.

answered Aug 22 '11 at 16:42

Vinicius Kamakura

7,665
1
29
43

score 0 · Answer 5 · answered Aug 22 '11 at 16:42

The strcat() function appends the src string to the dest string, overwriting the null byte ('\0') at the end of dest, and then adds a terminating null byte. The strings may not overlap, and the dest string must have enough space for the result.

buffer is not '\0' terminated, as it is not initialized, we do not know what it contains. Therefore it is an undefined behavior. You should first make sure the buffer is '\0' terminated.

And the number printed is not a random number it is the starting address of the buffer.

C memory question

5 Answers5