Java开发者的C语言技术疑问：长度1的char数组存字符串及字符串数组实现

Hey Alex! I totally get the confusion jumping from Java to C—they have some pretty different rules under the hood. Let's break down your questions one by one:

1. Is char a[0] = 'abcd'; valid in C? #

Short answer: No, this is not valid (and will cause problems). Here's the breakdown:

• First, standard C (any version from C90 onward) doesn't allow arrays with a length of 0. Some compilers like GCC support it as a non-standard extension, but even then, a zero-length array has no allocated storage space—there's nowhere to store any data.
• Second, 'abcd' is a multi-character constant, which in C gets treated as an int value (the exact number depends on your system's endianness, but it's definitely not a string). Trying to assign this integer to a zero-length char array is a type mismatch and leads to undefined behavior (think crashes, garbage values, or unpredictable program behavior).
• If you wanted to store the string "abcd" properly, the correct syntax would be char a[] = "abcd";—this automatically sets the array length to 5, including the required null terminator \0 that C uses to mark the end of a string.

2. How to create a length-1 string array like Java's String[] a = new String[1]; a[0] = "text";? #

In Java, a String[] holds references to string objects. In C, the equivalent is an array of character pointers, since strings are represented as null-terminated char sequences and we use pointers to reference them. Here are two common approaches:

Option 1: Static initialization (for fixed, unchanging strings) #

This is the simplest method, perfect if you don't need to modify the array later:

// Use const because string literals are read-only in C
const char* a[1] = {"text"};

This creates an array of 1 pointer, where a[0] points to the string literal "text" (stored in read-only memory). You can access it just like in Java—for example, printf("%s\n", a[0]); will print "text".

Option 2: Dynamic allocation (for flexible use cases) #

If you need to create the array on the fly or modify its elements later (like replacing the string with user input), use dynamic memory allocation:

#include <stdlib.h>
#include <string.h>

int main() {
    // Allocate memory for 1 char pointer
    char** a = malloc(sizeof(char*) * 1);
    if (a == NULL) {
        // Always check for allocation failure!
        return 1;
    }

    // Duplicate the string literal into allocated memory (strdup is POSIX; for standard C, use malloc + strcpy)
    a[0] = strdup("text");
    // Standard C alternative:
    // a[0] = malloc(strlen("text") + 1);
    // if (a[0] != NULL) strcpy(a[0], "text");

    // Use the string
    printf("%s\n", a[0]);

    // Don't forget to free memory to avoid leaks (C doesn't have garbage collection!)
    free(a[0]);
    free(a);
    return 0;
}

内容的提问来源于stack exchange，提问作者Alex Sparrow