C - why is strcpy() necessary

Can someone please explain to me why strcpy() is necessary to assign strings to character arrays, such as in the following code snippet.

int main(void) {

char s[4];

s = "abc"; //Fail开发者_高级运维s
strcpy(s, "abc"); //Succeeds

return 0;
}

What is the reason that s = "abc" fails? And why is strcpy() the only way to assign strings to char arrays after they have been declared? It seems strange to me that you have to use a function to carry out a basic assignment.

Arrays in C are non-assignable and non-copy-initializable. That's just how arrays are in C. Historically, in value context (on the RHS of assignment) arrays decay to pointers, which is what formally prevents assignment and copy-initialization. This applies to all arrays, not only to char arrays.

C language inherits this arrays behavior from its predecessors - B and BCPL languages. In those languages arrays were represented by physical pointers. (And obviously re-assignment of pointers is not what you'd want to happen when you assign one array to another.) In C language arrays are not pointers, yet they do "simulate" the historical behavior of B and BCPL arrays by decaying to pointers in most cases. This historical legacy is what keeps C arrays non-copyable to this day.

One exception from the above is the initialization with a string literal. I.e. you can do

char c[] = "abc";

in which case conceptually we are copying string literal "abc" to array c. Another exception is array wrapped into a struct type, which is copied when the whole struct object is copied. And that's about it.

This means that whenever you want to copy a naked (non-wrapped) array, you have to use a library-level memory copying function, like memcpy. strcpy is just a flavor of that specifically tailored to work with strings.

That's simply what arrays are in C. You can't assign to them. You can use pointers if you like:

char *p;
p = "abc";

Incidentally, there is a C FAQ.

Arrays are ``second-class citizens'' in C; one upshot of this prejudice is that you cannot assign to them.

Short answer: historical reasons. C never had a built in string type. It wasn't until C++ came along that std::string came into being, and even that did not arrive with the first implementations

Long answer: the type of "abc" is not char[], but rather char *. strcpy is one mechanism with which you can copy the data that the pointer points at (in this case that's ABC).

strcpy isn't the only way to initialize an array, however, it is smart enough to detect and respect the terminating 0 at the end of the string. You could also use memcpy to copy the string into s but that requires you pass in the length of the data to be copied, and to ensure the terminating 0 (NULL) is present in s

The C language lacks any convenient syntax for getting a pointer to a string literal along with an indication of its length. Some languages including many Pascal dialects prefix each string with a byte reporting its length; this works nicely for many purposes, but limits string literals to 255 characters. C's approach allows string literals of any length to be accommodated, but adds only a single byte of overhead regardless of length.

Zero-terminated strings are inferior to other forms for almost every purpose other than string literals, but literals are so far and away the most common form of string that many programs will have to deal with, and thus there is considerable advantage to having library functions deal with them effectively; it then becomes easier to use zero-terminated strings in cases where they are less than ideal than to have a separate set of library routines for other types.