One-Dimensional Array Creation and Initialization

In C programming, arrays represent collections of elements with identical data types.

data_type array_name [constant_size];
//data_type specifies the element type
//constant_size defines array capacity through a constant expression

Examples of array declarations:

int numbers[5];
char letters[6];
float values[7];
double data[4 + 4]; // expressions are also valid

Key considerations:

• Array size specification requires compile-time constants in standard C
• C99 introduced variable-length arrays allowing runtime size determination
• Variable-length arrays fix size at declaration, not dynamic resizing

Array Initialization Process

Distinguishing initialization from assignment:

int initial_value = 0;  // initialization
int variable;
variable = 0;           // assignment

Numeric array initialization patterns:

// Partial initialization - first element set, others zeroed
int partial[10] = { 1 };     
// Complete initialization   
int complete[10] = { 1,2,3,4,5,6,7,8,9,10 };
// Size inferred from initializer count
int inferred[] = { 1,2,3,4,5 };

Character array initialization methods:

// String literal - automatically appends null terminator
char text1[] = "hello";
// Character list - exact size match
char text2[] = { 'h', 'e', 'l', 'l', 'o' };

Important notes:

• String literals implicitly add '\0' termination
• Character lists match size to initializer count
• Global variables default to zero initialization
• Local variables contain garbage values without explicit initialization

Array Usage and Access

The subscript operator [] provides array element access:

int main()
{
    int sequence[] = { 1,2,3,4,5,6,7,8,9,10 };
    int length = sizeof(sequence) / sizeof(sequence[0]);
    
    for (int index = 0; index < length; index++)
    {
        printf("%d ", sequence[index]);
    }
    return 0;
}

Fundamental principles:

• Zero-based indexing scheme
• Array size calculation through sizeof operations
• Variables permitted during usage despite creation restrictions

Memory Storage Characteristics

Examining memory layout through address analysis:

int main()
{
    int elements[] = { 1,2,3,4,5,6,7,8,9,10 };
    int count = sizeof(elements) / sizeof(elements[0]);
    
    for (int pos = 0; pos < count; pos++)
    {
        printf("Address of elements[%d]: %p\n", pos, &elements[pos]);
    }   
    return 0;
}

Storage properties:

• Contiguous memory allocation
• Sequential address progression with index growth
• Element spacing matches data type size requirements

Two-Dimensional Array Operations

Declaration Syntax

int matrix[rows][columns];     // integer 2D array
double grid[rows][columns];    // double precision array
float table[rows][columns];    // floating point array

Initialization Techniques

int flat_init[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
int grouped_init[3][4] = { {1,2,3,4},{5,6,7,8},{9,10,11,12} };
int partial_init[][4] = { {1,2},{3,4} };  // row count optional

Critical constraints:

• Column specification mandatory during declaration
• Row specification optional for initialization
• Compiler requires column knowledge for memory offset calculations

Access Patterns

int dataset[][4] = { {1,2,3,4},{5,6,7,8},{9,10,11,12} };

for (int row = 0; row < 3; row++)
{
    for (int col = 0; col < 4; col++)
    {
        printf("%d ", dataset[row][col]);
    }
    printf("\n");
}

Memory Organization

Two-dimensional arrays maintain contiguous storage:

int sample[][4] = { {1,2},{3,4},{5,6} };

for (int r = 0; r < 3; r++)
{
    for (int c = 0; c < 4; c++)
    {
        printf("sample[%d][%d] address: %p\n", r, c, &sample[r][c]);
    }
}

Array name semantics:

• Array name represents first element address
• Each row functions as independent one-dimensional array
• Row-specific addresses enable localized access patterns

Boundary Violation Issues

Index Range Errors

int matrix[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };

for (int i = 0; i < 3; i++)
{
    for (int j = 0; j < 5; j++)  // exceeds column limit
    {
        printf("%d ", matrix[i][j]);  // accesses invalid memory
    }
    printf("\n");
}

Buffer Overflow Scenarios

char buffer[] = "";  // size limited to single null terminator
scanf("%s", buffer); // potential overflow with multi-character input

int small_array[] = { 0 };
for (int idx = 0; idx < 10; idx++)
{
    small_array[idx] = idx;  // exceeds allocated space
}

Arrays as Function Parameters

Incorrect Sorting Implementation

void display_data(int* array, int size)
{
    for (int i = 0; i < size; i++)
    {
        printf("%d ", array[i]);
    }
    printf("\n");
}

void flawed_sort(int array[10])  // problematic approach
{
    int elements = sizeof(array) / sizeof(array[0]);  // incorrect calculation
    
    for (int pass = 0; pass < elements - 1; pass++)
    {
        for (int compare = 0; compare < elements - 1 - pass; compare++)
        {
            if (array[compare] > array[compare + 1])
            {
                int temp = array[compare];
                array[compare] = array[compare + 1];
                array[compare + 1] = temp;
            }
        }
    }
}

Array Name Semantic Rules

Three exceptional cases where array names retain full identity:

1. sizeof(array_name) returns total array byte size
2. &array_name yields complete aray address
3. All other contexts evaluate to first element adress

int collection[] = { 1,2,3,4,5,6,7,8,9,10 };
printf("sizeof result: %zu\n", sizeof(collection));  // outputs 40 bytes
printf("First element: %p\n", &collection[0]);       // element address
printf("Array address: %p\n", collection);          // same as above
printf("Full array: %p\n", &collection);            // entire array address

Corrected Sorting Solution

void improved_bubble(int array[], int size)
{
    for (int iteration = 0; iteration < size - 1; iteration++)
    {
        int sorted = 1;
        for (int pair = 0; pair < size - 1 - iteration; pair++)
        {
            if (array[pair] < array[pair + 1])
            {
                int swap = array[pair];
                array[pair] = array[pair + 1];
                array[pair + 1] = swap;
                sorted = 0;
            }
        }
        if (sorted) break;
    }
}

void output_sequence(int* data, int quantity)
{
    for (int position = 0; position < quantity; position++)
    {
        printf("%d ", data[position]);
    }
}

int main()
{
    int sequence[] = { 5,2,8,1,9,3,7,4,6,0 };
    int length = sizeof(sequence) / sizeof(sequence[0]);
    
    output_sequence(sequence, length);
    improved_bubble(sequence, length);
    output_sequence(sequence, length);
    return 0;
}

Pointer-Based Array Traversal

Address arithmetic for element access:

int items[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* pointer = items;  // equivalent to &items[0]

for (int offset = 0; offset < 10; offset++)
{
    printf("%d ", *(pointer + offset));
}

Equivalence relationships:

int main()
{
    int source[10] = { 1,2,3,4,5,6,7,8,9,10 };
    int* ref = source;

    // All expressions produce identical results:
    for (int i = 0; i < 10; i++) printf("%d ", source[i]);
    for (int i = 0; i < 10; i++) printf("%d ", *(source + i));
    for (int i = 0; i < 10; i++) printf("%d ", *(ref + i));
    for (int i = 0; i < 10; i++) printf("%d ", ref[i]);
    
    return 0;
}

Mathematical equivalences:

• array[index] ≡ *(array + index)
• *(index + array) ≡ index[array]
• Pointer and array notation interchangeability