Lecture 6: Arrays in C and Operations

• Lecture 6 is about Arrays in C
• Discusses operations with Arrays
• Shows Array operations using pointers

Array and Operations

• A data structure defines how certain types of data values are represented, organized, stored, and operated in programs and computers.
• In programs data structures are used to represent a collection of data items of certain types together with a set of operations that can be performed on the data items.
• The simplest data structure is a list of variables.
• Local variables of a function are instanced in contiguous memory space in call stack when the function is called.
• Global variables are instanced in contiguous memory space in the data region.
• A list of variables is doable when the number of data items is fixed and small.
• A list of variables is not doable when the number of data items is large.
• Array is a solution when the data items are of the same data type.
• Data items are classified into groups
• A group contains data items of the same type
• Arrays represent the groups of data items

Concepts of Arrays

• An array is a collection of data values, also known as elements, of the same data type.
• Array elements are organized in linear order and stored in contiguous memory locations one after another.
• The linear relation of array elements is determined by the adjacency of elements in memory.
• These allow access to any array element directly by its ordering position (index) in memory.

Array Syntax

• Array declaration syntax: data_type array_name[length];
• data_type represents the data type of array elements
• array_name represents the name, or identifier, of array
• length represents total number of array elements
• The compiler allocates sizeof(data_type)*length bytes contiguous memory cells, or memory block, for the array.
• Array elements are named array_name[0] ... array_name[length-1]
• An array element at index i is accessed: array_name[i], for i = 0, ..., length-1.
• The random accessing array element defines that given an index i, one can set or get value by array_name[i]
• Array Traversal by index: for (int i = 0; i<length; i++) process(array_name[i]);

Array Addresses

• An array element is a variable; array_name[0] is a variable name, can be used set and get value, its address is &array_name[0]
• The address of an array is the address of its first element, represented by the array name, array_name.
• It is the address of the first element, i.e., &array_name[0]
• It is the address of the first memory cell of the block of array_name[0].

Array Examples

• int a[10]; declares an array of int type, name a, length = 10
• The above allocates a memory block of 10*4 bytes
• Arrays are accessed by a[index], index from 0 to 9, a[0], ..., a[9]
• The smallest index is 0, maximum index 9
• sizeof(a) returns the total number of bytes of array a, i.e., 40 bytes
• sizeof(a[0]) returns the number of bytes of a[0], which is 4
• sizeof(a)/sizeof(a[0]) returns the length of array a
• a[2] = 10; assigns or sets value to array element a[2]
• int b = a[2]; gets the value of array element at position/index 2 and assign to b

Array Traversal Example

• Declares an array of int data as global variables: int list[SIZE];
• Declares an array of int data type, local variables: int list[SIZE];
• list in the example code is instanced in data region
• list in the example code is instanced in stack region

Array Initialization

• int a[5]; represents no initialization, the elements holds whatever value was there previously.
• int a[5] = { 4, 1, 7, 2, 1 }; Tells compiler to generate instructions to set values to elements in order, each element gets a value.
• int a[5] = { 4, 1, 0 }; The first three elements get values 4, 1, 0, the rest are set to 0
• int a[5] = { 0}; All elements are initialized to 0
• int a[] ={1, 2, 3, 4, 5}; Declares length 5 automatically and gets the initial values

Passing Arrays to Functions

• Arrays can be passed by array element values
• Arrays can be passed by element reference, i.e., address of element
• Arrays can be passed by array name, i.e., the address of the first element together with the length of the array.

Creating Arrays by Dynamic Method

• Arrays created by declaration method are statically or automatically allocated arrays.
• Memory blocks of arrays are allocated in the stack region if they are declared in functions
• Memory blocks of arrays are allocated in the data region if they are declared outside all functions.
• Arrays can also be created by using the dynamic method
• This method involves using the stdlib function malloc() to allocate memory space for an array.
• Arrays created by the dynamic method are called dynamic arrays.
• Memory blocks of dynamic arrays are allocated in the heap region at runtime.

Array Pointer and Examples

• This code allocates a memory block of 20 bytes in the heap region.
• a in the example code is in heap region
• Array can be operated efficiently by using pointers.
• If pointer ptr holds the address of an array element, then ptr++ represents the address of the next element, ptr-- represents the address of the previous element.
• This code shows an example:

int a[] = {1, 2, 3};
int *ptr = &a[0]; // or equivalently int *ptr = a;
printf ("%d", *ptr); // output 1
ptr++; // equivalent to ptr = ptr+1;
printf ("%d", *ptr); // output 2
ptr--;
printf ("%d", *ptr); // output 1

• The three programs in the slides do the equivalent things
• The last program is the most efficient
• The last program demonstrates less computation for index and addressing

Array of Pointers and Examples

• C allows array of pointers, each array element is a pointer.
• Array of pointers is a useful feature for data representation.
• If you have this code, printf("\n %d", *ptr[3]);, what will it print?

 int *ptr[5]; // declare an array of 5 int type pointer values (addresses of int data)
 int p=1, q=2, r=3, s=4, t=5;
 ptr[0]=&p;
 ptr[1]=&q;
 ptr[2]=&r;
 ptr[3]=&s;
 ptr[4]=&t;

• An array pointer is a pointer pointing to an array.
• An array can be viewed as a derived data type.
• An array pointer is a pointer pointing to such a data type variable.
• An array pointer can be declared by syntax: data_type (*arr_ptr_name)[k];
• arr_ptr_name is a pointer to an array of type data_type of length k.
• *arr_ptr_name represents a pointer pointing the first element of the array
• Code example:

int a[5];
int (*ptr)[5]; // different from int *ptr[5];
int *p = a; // p points to a[0], p++ will increase by sizeof(int)
ptr = &a; // ptr and p has the same value, but ptr++ will increase by sizeof(int)*5.
- ptr points a[0], *ptr + i points to a[i], *(*ptr + i) gives a[i]

Lecture on arrays in C programming. Covers array operations and how to implement them using pointers. Explains how arrays provide a solution for managing large collections of same-type data items.