C：为什么字符串变量接受的字符多于其大小？

Question

I have following code and the out put:-

#include<stdio.h>
int main()
{
char pal_tmp[4];
printf("Size of String Variable %d\n",sizeof(pal_tmp));
strcpy(pal_tmp,"123456789");
printf("Printing Extended Ascii: %s\n",pal_tmp);
printf("Size of String Variable %d\n",sizeof(pal_tmp));
}

Out put:-

Size of String Variable 4
Printing Extended Ascii: 123456789
Size of String Variable 4

My questions is Why String variable (character array) accepts characters more than what its capacity is? Should not it just print 1234 instead of 123456789 ?

Am I doing something wrong?

Answer 1

Well yes. You are doing something wrong. You're putting more characters into the string than you are supposed to. According to the C specification, that is wrong and referred to as "undefined behaviour".

However, that very same C specification does not require the compiler (nor runtime) to actually flag that as an error. "Undefined behaviour" means that anything could happen, including getting an error, random data corruption or the program actually working.

In this particular case, your call to strcpy simply writes outside the reserved memory and will overwrite whatever happens to be stored after the array. There is probably nothing of importance there, which is why nothing bad seems to happen.

As an example of what would happen if you do have something relevant after the array, let's add a variable to see what happens to it:

#include <stdio.h>

int main( void )
{
    char foo[4];
    int bar = 0;

    strcpy( foo, "a long string here" );
    printf( "%d\n", bar );

    return 0;
}

When run, I get the result 1701322855 on my machine (the results on yours will likely be different).

The call to strcpy clobbered the content of the bar variable, resulting in the random output that you saw.

Answer 2

Well yes, you are overwriting memory that doesn't belong to that buffer ( pal_tmp ). In some cases this might work, in others you might get a segfault and your program will crash. In the case you showed, it looks like you happened to not overwrite anything "useful". If you tried to write more, you'll be more likely to overwrite something useful and crash the program.

Answer 3

C arrays of char don't have a predefined size, as far as the string handling functions are concerned. The functions will happily write off the end of the array into other variables ( bad ), or malloc 's bookkeeping data ( worse ), or the call stack's bookkeeping data ( even worse ). The C standard makes this undefined behaviour, and for good reason.

If a version of a particular function accepts a size argument to limit how much data it writes, use it . It protects you against this stuff.

Answer 4

C does not keep track of the size of strings (or arrays, or allocated memory, etc.), so that is your job. If you create a string, you must be careful to always make sure it never gets longer than the amount of memory you've allocated to it.

Answer 5

In C language Strings are defined as an array of characters or a pointer to a portion of memory containing ASCII characters. A string in C is a sequence of zero or more characters followed by a NULL '\\0' character. It is important to preserve the NULL terminating character as it is how C defines and manages variable length strings. All the C standard library functions require this for successful operation.

For complete reference refer this

Answer 6

Function strcpy doesn't have knowledge about the length of the character array - this function is considered as unsecure.

You may use strncpy, where you tell the size of the buffer and if longer argument is provided, only the memory of the buffer is used and nothing else is changed.