How can I initialize all members of an array to the same value in C?

To initialize all members of an array to the same value in C, the approach depends on the value type and whether you need compile-time or runtime initialization. Here’s a detailed guide with examples:

1. Zero Initialization (All Elements to 0)

Use {0} in the initializer. This works for all data types and is compile-time optimized.

// Example: Initialize all elements to 0
int arr[5] = {0}; // All elements are 0
char str[10] = {0}; // All elements are '\0'

Explanation:

• C automatically fills unspecified elements with 0.
• Works for static, global, and local arrays.

2. Non-Zero Value Initialization

a. For Compile-Time Initialization (Standard C)

No direct way for non-zero values. You must specify all elements explicitly (impractical for large arrays):

int arr[5] = {5, 5, 5, 5, 5}; // All elements = 5

b. For Runtime Initialization (Loop)

Use a loop to assign the value to each element:

int arr[5];
for (int i = 0; i < 5; i++) {
    arr[i] = 5; // All elements = 5
}

c. Using memset (Byte-Level Initialization)

• Works for:
• 0 or -1 (for integer types, as memset sets each byte).
• Character arrays (e.g., char, unsigned char).

// Example 1: Zero-initialize an integer array
int arr[5];
memset(arr, 0, sizeof(arr)); // All elements = 0

// Example 2: Initialize a char array to 'A'
char str[10];
memset(str, 'A', sizeof(str)); // All elements = 'A'

// Example 3: Incorrect for non-zero integers (⚠️)
int arr[5];
memset(arr, 1, sizeof(arr)); // Sets each byte to 0x01 → ints = 0x01010101

3. GCC Extension: Designated Initializers (Non-Standard)

GCC allows range-based initialization using [start ... end] = value:

int arr[5] = {[0 ... 4] = 5}; // All elements = 5 (GCC only)

Note: Not portable; use only if compiler-specific code is acceptable.

4. Static/Global Arrays (Partial Compile-Time)

For static or global arrays, you can combine loops with macros (but still runtime for non-constant values):

#define SIZE 5
#define VALUE 5

static int arr[SIZE];
// Initialize once at program start (not truly compile-time)
static void __attribute__((constructor)) init_array() {
    for (int i = 0; i < SIZE; i++) arr[i] = VALUE;
}

Key Considerations

Method	Use Case	Portability
{0}	Zero-initialize any array	Standard C
Explicit initializer	Small non-zero arrays	Standard C
Loop	Runtime initialization	Standard C
memset	Byte-level patterns (e.g., 0, -1)	Standard C
GCC designated ranges	Non-zero values (GCC only)	Compiler-specific

Examples

Zero-Initialized Array

int arr[5] = {0}; // All elements = 0

Runtime Loop for Non-Zero

double values[100];
for (int i = 0; i < 100; i++) {
    values[i] = 3.14; // All elements = 3.14
}

Char Array with memset

char buffer[256];
memset(buffer, 'x', sizeof(buffer)); // All elements = 'x'

Summary

• Zero: Use {0} or memset for simplicity.
• Non-Zero: Use loops for runtime or explicit initializers for small arrays.
• GCC Extensions: Use [0 ... N] = value for non-portable code.
• Avoid memset for Non-Byte Values: It sets bytes, not the full value of multi-byte types like int.