C语言中char *a[]={"yes","no"}等字符串声明是否需malloc？

Great question—this is a super common point of confusion when you’re getting the hang of C string handling. Let’s break down each scenario clearly and clarify when malloc is (and isn’t) necessary:

Case 1: char *a = "hello" #

When you write this line, you’re not creating a string from scratch—you’re declaring a pointer a that points to a string literal ("hello") that your compiler already takes care of. Here’s the behind-the-scenes breakdown:

• The compiler stores the string "hello" in a read-only section of your program’s memory (usually called the .rodata segment) when it builds your executable.
• The pointer a just gets assigned the memory address of this pre-existing, ready-to-use string.

You don’t need malloc here at all. But a critical warning: string literals are read-only. If you try to modify the string (like a[0] = 'H'), you’ll trigger undefined behavior—your program might crash, act weird, or even seem to work by accident (don’t rely on that!).

Case 2: char *b[] = {"yes", "no"} #

This is an array of pointers, where each element points to a separate string literal. Just like the first case:

• Each string ("yes" and "no") is stored in the program’s read-only memory by the compiler during compilation.
• The array b itself is allocated on the stack (if it’s a local variable) or in the global data segment (if it’s a global variable), and each slot in b holds the address of one of those pre-defined literals.

Again, no malloc is required here. You can’t modify the underlying string literals, but you can reassign the pointers in the array (like b[0] = "maybe"—that’s totally safe).

When Would You Need malloc? #

You only need malloc (or related functions like calloc or realloc) when you need:

• A modifiable string that you can edit after creation (since string literals are locked down). For example:

  char *modifiable_str = malloc(6); // Allocate space for "hello" + null terminator
  strcpy(modifiable_str, "hello");
  modifiable_str[0] = 'H'; // This works perfectly!
  

• A string whose length isn’t known at compile time (like a string built from user input or dynamic data).
• A string that needs to outlive the scope where it’s created (e.g., returning a string from a function—stack-allocated strings get destroyed when the function exits, so you’d use malloc to allocate on the heap instead).

内容的提问来源于stack exchange，提问作者Alon T