C - why is strcpy() necessary

Question

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"; //Fails
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.

Guipure

Answer 1

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.

Immortal

Just to clarify, all array types can be initialized with a proper initializer of the form { val0, val1, ... }. – Iraq

You don't have to use a library function; you can assign individual characters, e.g. for (char *dst = s, *src = "abc"; *dst++ = *src++;) ;. The library function is a better choice though, as it is easier to read and may be optimized for the system. – Dispenser

Yeah, to touch more on what @AnT said, strcpy() is almost exactly like memcpy(), except that it includes the null-byte. – Disagreement

Answer 2

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.

Itself

Yeah I do use pointers, I just don't understand why s = "abc" doesn't work in my example. s is a char array, and so is "abc"... – Guipure

@Guipure - no, s is a char array, "abc" is a pointer to constant string. – Shorts

@MByD: Not entirely correct. "abc" is not a pointer. "abc" an array of type char[4], which in this context decays to a pointer of type char *. Note, that in C the string is not constant. It is non-modifiable all right, yet the type itself does not include const qualifier. – Immortal

@AndryT: To be even pickier, "const" and "constant" are two very different things. "const" probably should have been called "readonly". A constant, or a constant expression, is one that can be evaluted at compile time; a const object is one that cannot be modified at runtime. Consider const int r = rand();. – Aphoristic

Answer 3

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

Illuminati

The type of "abc" is char[4]. – Iraq

And strcpy isn't an initialization but an assignment. Character arrays can be initialized as all other arrays, see AndreyT's answer. – Iraq

Answer 4

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.

Darrelldarrelle