更改 char[] 数组的元素

Question

I find strings or character arrays in C confusing, so I tend to make mistakes and errors while writing code. The below code takes in a character array and while printing, prints the fourth element as x .

void printString(char stuff[]) {
    for (int i = 0; i < 5; i++) {
        if (i == 3) {
            stuff[i] = 'x';
        }
        printf("%c", stuff[i]);
    }
}

int main(void) {
    char z[] = "hello";
    printString(z); // output helxo

When trying to apply the same concept with an array of character arrays, you can't change the values

void printStrings(char stuff[5][20]) {
    for (int i = 0; i < 5; i++) {
        if (i == 4) {
            stuff[i] = "Not Cool"; // Error: assignment to expression with array type
        }
        printf("%s\n", stuff[i]);
    }
}

int main(void) {
    char a[5][20] = {
        "Words",
        "More Words",
        "Letters",
        "Arrays",
        "Cool"
    }
}

Any help would be appreciated.

PS Any links to a resource explaining character arrays and strings would also be helpful:)

Answer 1

The = operator is not defined to copy the contents of one array to another. You either have to copy each array element individually in a loop:

for ( size_t i = 0; i < num_elements; i++ )
  dst[i] = src[i];

or you have to call a library function like strcpy (for arrays that contain strings) or memcpy (for arrays that don't contain strings), which does pretty much the same thing under the hood.

Arrays and array expressions in C are weird compared to other aggregate types like struct or union ; as part of that weirdness, array expressions are not allowed to be the target of an assignment operator. Under most circumstances, an expression of type "array of T " is converted, or "decays", to an expression of type "pointer to T " and the value of the expression is the address of the first element of the array.

This isn't arbitrary - Ritchie had a reason for making arrays behave this way - but it doesn't make it any less weird.

Answer 2

When trying to apply the same concept with an array of character arrays, you can't change the values

Yes you can, just not the way you are doing it. You can't assign one array to another. But you can use strcpy() instead to copy characters from one array to another, eg:

strcpy(stuff[i], "Not Cool");

Or better, strncpy() , eg:

strncpy(stuff[i], "Not Cool", 20);

Answer 3

When trying to apply the same concept with an array of character arrays, you can't change the values

The problem is not that you cannot change the values. It is exactly as the compiler tells you: you cannot assign to whole arrays.

Given this declaration:

 void printStrings(char stuff[5][20]) {

Parameter stuff is a pointer to an array of 20 char s. stuff[4] therefore designates an array, and is not an lvalue -- you cannot assign to it. But you can modify its elements via assignment, or, more generally, you can modify its contents via appropriate functions, such as strcpy() .

    stuff[4][0] = 'f';

I find strings or character arrays in C confusing

There are some confusing things about C strings, but one thing that I hope will help you is to recognize that strings and character arrays are not the same thing. Strings are values that may be represented by the contents of character arrays. Even when a character array contains a string (because any one or more of its elements has value '\0' and therefore serves as a string terminator) the array itself is not the string, even though we are sometimes a bit lax with our language around such things.

Compound that with the fact that string literals have their own quirks, and arrays in general have quirks, and yes, there is plenty of room for confusion.

Answer 4

The misconcept you have comes from the fact that you think that arrays are assignable, as are other objects. The C concept of array is a bit poor. When you use the array identifier as a whole, you are not meaning the whole array, but just the (constant) address of it's first element (like with a pointer), so you cannot write something like:

char A[100], B[100];
A = B; /* error, A is a constant address (the address of A array) and B is a constant address, so A is not assignable. */

This is very efficient when passing arrays as parameters to functions, because it avoids to copy the whole array into the parameter list, and just a pointer is put in it. It also freed the original C implementors to write code to copy full blocks of memory when you assigned arrays (which is something that is scarcely used in programming)

To provide a solution, they wrote a family of functions that allow you to copy arrays or strings (which are arrays of char ). You can use:

#include <string.h>
...
       strcpy(stuff[i], "Not cool");

and this will make the string literal to be copied at position of the i -esim array element.

You stated that

When trying to apply the same concept with an array of character arrays, you can't change the values

but in your first case you were assigning a single char object (which as an scalar value is assignable in C) when you switched to arrays, you got to the fact that a whole array is not assignable in C.