Arrays in C Programming: Operations on Arrays

Arrays in C Programming: An Overview

Computer programming is an ever-evolving field that demands individuals to stay up to date with the latest development technologies and languages. To solidify your skills, you can also look into theC Certification Course. Arrays provide efficient storage and access to data, making them a crucial component in programming. In this article of C tutorial, we will cover what arrays in C are used when creating programs. We'll offer examples along the way so you'll be able to learn from a hands-on approach!

What are Arrays in C Programming?

An Array in C programming language is a powerful data structure that allows users to store and manipulate a collection of elements, all of the same data type in a single variable. Simply, it is a collection of elements of the same data type.

Arrays are the derived data type in C that can store values of both - fundamental data types like int, and char; and derived data types like pointers, and structure. The values get stored at contagious memory locations that can be accessed with their index number.

Syntax

dataType arrayName[arraySize];

Example

int a[5];

Here, an integer type array a is declared with the size 5. It can store 5 integer values.

Properties of an Array in C

• Declaration: Arrays in C are declared by specifying the data type of the elements and the number of elements in the array.
• Indexing: Elements in an array are accessed using an index. The index of the first element in an array is always 0.
• Memory allocation: Arrays in C are allocated contiguous memory locations at the time of declaration. The amount of memory allocated for an array is equal to the product of the number of elements and the size of each element.
• Initialization: Arrays in C can be initialized at the time of declaration or later.
• Size: The size of an array is the number of elements in the array. The size of an array can be calculated using the sizeof() operator.
• Manipulation: Arrays in C can be manipulated using loops, functions, and other programming constructs.

Types of Arrays in C

There are two types of array in C, which are:

1. Single-dimensional array: It is a collection of elements of the same data type that are stored in a contiguous block of memory.
2. Multi-dimensional array: It is an array that contains one or more arrays as its elements. We will see this in the next section multidimensional arrays in C.

In this tutorial we will cover all the aspects of a Single dimensional array

Initializing Array in C

• Initialize at the time of declaration using “{}”.

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

• Initialize an array without specifying its size at declaration time.

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

  Though we haven't specified the size, the compiler understands the size as 5 due to the initialization of 5 elements.

• Initialization by using the index of an element

  int marks[5];
  marks[0]=80; //the index of an array starts with 0.
  marks[1]=60; 
  marks[2]=70; 
  marks[3]=85; 
  marks[4]=75;
  

Accessing Elements of an Array in C

Example

#include <stdio.h>
int main() {
 int a[] = {25, 50, 75, 100};
 printf("%d\n", a[0]);
 printf("%d\n", a[1]);
 printf("%d\n", a[2]);
 printf("%d\n", a[3]);
 printf("%d\n", a[4]);
 return 0;
}

Output

25
50
75
100
45

Remember that when you access an unavailable element in an array, the program may result in an unexpected output (undefined behavior). Sometimes you might get an error and some other times your program may run correctly.

Changing the Elements of an array in C

Example

#include <stdio.h>
int main()
{
 int a[] = {25, 50, 75, 100, 45};
 a[3] = 60;
 printf("%d\n", a[3]);
 return 0;
}

Output

60

Traversing an Array in C

Example

#include <stdio.h>
int main(){
int i=0;
int marks[5];//declaration of array
marks[0]=90;//initialization of array
marks[1]=80;
marks[2]=70;
marks[3]=95;
marks[4]=85;

//traversal of array
for(i=0;i<5;i++){
printf("%d \n",marks[i]);
}//end of for loop
return 0;
}

Output

90
80
70
95
85

Input and Output Array Elements in C

Example

// Program to take values of the array from the user and print the array

#include <stdio.h>
int main()
{
 int a[5];
 printf("Enter the values of an integer array:\n ");

 // taking input and storing it in an array
 for(int i = 0; i < 5; ++i) {
 scanf("%d", &a[i]);
 }
 
 printf("Displaying integers: ");
 // printing elements of an array
 for(int i = 0; i < 5; ++i) {
 printf("%d\n", a[i]);
 }
 return 0;
}

The above code uses the for loop to take input values for an array a. After storing the elements in an array, it again uses the for loop to print all of them.

Output

Enter the values of an integer array:
1
2
3
4
5
Displaying integers:
1
2
3
4
5

Advantages of an Array in C

• Efficient memory usage: Arrays in C use contiguous memory locations to store the elements, thus making it efficient to allocate and access data.
• Easy access to elements: Elements in an array can be accessed using their index, making it easy to retrieve specific data from the array.
• Better performance: Accessing elements in an array using an index is faster than using other data structures like linked lists or trees. This is because the index provides direct access to the memory location where the element is stored.
• Flexibility: Arrays in C can be used to store different types of data, including integers, characters, and strings.
• Easy to implement algorithms: Many algorithms in computer science use arrays, making it easy to implement these algorithms in C.
• Compatible with other data structures: Arrays can be used in conjunction with other data structures in C, such as stacks and queues, to implement complex data structures and algorithms.
• Easy to pass to functions: Arrays can be easily passed as arguments to functions in C, making it easy to manipulate large amounts of data efficiently.

Disadvantages of an Array in C

• Fixed-size: Arrays in C have a fixed size determined at the time of declaration. There is no dynamic increase in the size of an array.
• Memory allocation: Arrays in C are allocated in contiguous memory blocks. If the array is very large, there may not be enough contiguous memory available for allocation.
• No bounds checking: C does not perform any bounds checking on arrays, so it is possible to access memory outside of the bounds of the array. This can lead to segmentation faults or other memory-related errors.
• Limited flexibility: Arrays in C have limited flexibility due to fixed size and dimensions. This makes it difficult to implement certain algorithms and data structures that require dynamic resizing and manipulation.
• Inefficient for insertion and deletion: Inserting or deleting elements from an array in C can be inefficient, as it requires shifting all the elements after the insertion or deletion point to make room or fill in the gap. This can be time-consuming, especially for large arrays.
• Not suitable for non-numeric data: While arrays in C are well-suited for storing numeric data, they aren’t ideal for storing non-numeric data, such as strings or complex data structures. This is because C does not provide built-in support for these types of data structures.

Summary

After reading this article, you might have understood Arrays in C. They promote time efficiency and code readability. You'll be surprised by the amount you can achieve with just a few lines of code in C!. If you're interested in more tips and guidance on Arrays in C, consider exploring our site, where you can find comprehensive learning materials and tutorials. Additionally, if you want to solidify your knowledge and demonstrate your expertise, you may also consider a C Certification, which can validate your skills and enhance your credibility in the field.