Difference Between Array And String In C

A collection of items of identical data type stored in adjacent memory locations is called an array. Elements within an array are accessed using an index ranging from 0 to one less than the array's total size. Arrays can hold various data types such as characters, integers, floating-point numbers, and structures. In C, when creating an array, it is essential to specify the data type, size, and optionally, the initial values for its elements.

A string comprises a sequence of characters terminated by a null character ('0'). In C programming, strings are denoted as arrays of characters, where the last character is always a null character. Manipulation and definition of strings in C involve utilizing functions provided by the standard library, like strlen, strcat, strcpy, and strcmp. A string constant in C is enclosed in double quotation marks (" ") and automatically has a null character at the end.

Strings possess the essential quality of immutability, indicating that it is not possible to alter the individual characters within a string after its creation. Nonetheless, it is feasible to generate a fresh string by combining or duplicating current ones. In contrast, arrays are mutable, allowing for the modification of array elements through assignment operations or pointer calculations.

Size and Memory Allocation

One notable contrast between arrays and strings lies in the immutability of array size upon declaration, unlike strings which can dynamically adjust their size depending on the character count. For instance, a fixed size array of five integers occupies 20 bytes (considering each integer as four bytes), while a string consisting of five characters has a fixed size of six bytes (accounting for the characters and null character).

When initiating an array in C, it is essential to specify its size explicitly either by assigning a constant value or utilizing an initialized variable. For instance, we can create an integer array in the following manner:

int arr[5]; // declares an array of 5 integers

In C, conversely, it is possible to omit specifying the size and have the compiler assign the correct memory automatically. For example, we can define a string in the following manner:

char str[] = "hello"; // declares a string of 6 characters

The compiler reserves a total of six bytes of memory in this instance to store the string "hello," consisting of five characters along with the null terminator.

Accessing and Manipulating Elements

Elements within an array can be interacted with by referencing their specific indexes. The initial element in an array is denoted by an index of 0, while the final element is identified by the size minus one. By utilizing a for loop, it becomes possible to cycle through each element of an array and perform various tasks like sorting, searching, or displaying. Below is a demonstration showcasing the process of accessing and modifying a specific element within an array:

int arr[5] = {1, 2, 3, 4, 5};
arr[2] = 10; // changes the third element to 10

In this example, the third element of the array (with index 2) is changed to 10.

Characters within a string can be retrieved by specifying their positions, similar to how it's done in an array. Nevertheless, due to strings being unchangeable, direct alteration of their characters isn't possible. Instead, the approach involves creating a fresh string through concatenation or replication of existing ones. The C library offers string manipulation functions like strlen, strcat, strcpy, and strcmp.

Here is an illustration of altering a string utilizing the strcpy function:

char str1[] = "hello";
char str2[] = "world";
strcpy(str1, str2); // copies the contents of str2 to str1

In this instance, the contents of str2 are duplicated into str1, replacing the initial contents of str1.

Null Termination

The use of null termination in strings serves as a crucial distinction between arrays and strings within the C programming language. Strings are required to end with a null character ('\0') to indicate the end of the string. Without this null character, string manipulation functions would struggle to identify the string's endpoint, potentially leading to unpredictable outcomes or program crashes.

Arrays, conversely, do not necessitate null termination as they have the ability to hold various data types, including binary information and characters that cannot be printed. Nevertheless, in arrays, null termination is sometimes applied to signal the end of a series of elements, like a collection of characters or a stack of data.

Applications

Arrays and strings serve different roles and are utilized for diverse purposes within the C programming language. Arrays are valuable for holding a fixed quantity of similar data types, like a roster of scores, a numerical grid, or an array of indicators. Moreover, arrays can be leveraged to construct data organizations such as stacks, queues, and heaps.

Strings, conversely, serve the purpose of holding textual and character information such as names, locations, and communications. They are frequently employed in tasks involving input/output operations such as reading from and writing to files or the command line interface. Moreover, strings play a vital role in network programming and the administration of databases, where text is regularly transmitted or stored.

Here is an example C code that demonstrates the difference between arrays and strings:

C Program:

#include <stdio.h>
#include <string.h>

int main() {
    int arr[5] = {1, 2, 3, 4, 5}; // declaring an array of integers
    char str[] = "hello"; // declaring a string of characters
    
    // accessing elements of the array
    printf("The third element of the array is %d\n", arr[2]); // output: The third element of the array is 3
    
    // accessing elements of the string
    printf("The third character of the string is %c\n", str[2]); // output: The third character of the string is l
    
    // modifying elements of the array
    arr[2] = 10; // changing the value of the third element of the array
    printf("The new value of the third element of the array is %d\n", arr[2]); // output: The new value of the third element of the array is 10
    
    // modifying elements of the string
    str[2] = 'L'; // changing the value of the third character of the string
    printf("The new value of the third character of the string is %c\n", str[2]); // output: The new value of the third character of the string is L
    
    // copying arrays
    int arr_copy[5];
    memcpy(arr_copy, arr, sizeof(arr)); // copying the contents of arr to arr_copy
    printf("The first element of the copied array is %d\n", arr_copy[0]); // output: The first element of the copied array is 1
    
    // copying strings
    char str_copy[10];
    strcpy(str_copy, str); // copying the contents of str to str_copy
    printf("The copied string is %s\n", str_copy); // output: The copied string is hello
    
    return 0;
}

Output:

The third element of the array is 3
The third character of the string is l
The new value of the third element of the array is 10
The new value of the third character of the string is L
The first element of the copied array is 1
The copied string is heLlo

Explanation:

• ✅ This code demonstrates the difference between arrays and strings in C. In the beginning, we declare an array arr of 5 integers with values 1, 2, 3, 4, and 5, and a string str with the value "hello". We then access and print the third element of the array using arr[2], which has the value 3, and the third character of the string using str[2], which has the value 'l'.
• ✅ Next, we modify the third element of the array using arr[2] = 10, which changes its value from 3 to 10. We also modify the third character of the string using str[2] = 'L', which changes its value from 'l' to 'L'.
• ✅ We then demonstrate how to copy arrays and strings using the memcpy and strcpy functions, respectively. We declare a new array arrcopy and use the memcpy function to copy the contents of arr to arrcopy. We also declare a new string strcopy and use the strcpy function to copy the contents of str to strcopy. We print the first element of arrcopy, which has the value 1, and the contents of strcopy, which is "helloL". Note that the modified character 'L' is also copied to str_copy.
• ✅ Finally, we return 0 to indicate a successful termination of the program.

Conclusion

In summary, arrays and strings are fundamental data types within the C programming language, each possessing unique characteristics, functionalities, and uses. Arrays consist of elements of identical data types, featuring a set size and changeable contents. On the other hand, strings are character sequences ending with a null character, offering a flexible size and unchangeable contents. Recognizing the distinctions between arrays and strings is vital for developing effective and resilient C programs.