Array:
An array is a collection of elements of the same data type
stored in contiguous memory locations. Arrays are used to store and manipulate
multiple values of the same type under a single variable name. Each element in
an array is accessed by its index, starting from 0 for the first element.
Here's the basic syntax for declaring an array in C:
Example: -
data_type array_name[array_size];
-
`data_type`: Specifies the data type of elements in the array.
-
`array_name`: The name you give to the array.
-
`array_size`: The number of elements the array can hold.
Here are some examples of arrays in C:
1. Integer Array: An integer array is a data structure
that stores a collection of integer values in contiguous memory locations. You
can declare and manipulate integer arrays using C's array syntax. Here's how
you can work with integer arrays in C.
1. Declaration: To declare an integer
array, you need to specify its data type (int), a name for the array, and the
number of elements it can hold.
For
example:
int myArray[5]; // Declares an
integer array named myArray with 5 elements
2. Initialization: You can initialize an
array at the time of declaration or later using a loop or by assigning values
element by element. Here's an example of initialization during declaration:
i.e, - int
myArray[5] = {1, 2, 3, 4, 5};
Or, you can initialize it without
specifying the size:
i.e, - int
myArray[] = {1, 2, 3, 4, 5}; // The size is automatically determined as 5
3. Accessing Elements: You can access
elements of an array using the array index, starting from 0.
For
example:
int value = myArray[2]; // Access
the third element (index 2)
4. Modifying Elements: You can modify
the elements of an array by assigning new values to them.
For
example:
myArray[2] = 10; // Change the
third element to 10
5. Array Size: You can find the size
(number of elements) of an array using the `sizeof` operator.
For
example:
int size = sizeof(myArray) /
sizeof(myArray[0]);
6. Iterating Through an Array: You can
use loops like `for` or `while` to iterate through the elements of an array.
For
example:
for (int i = 0; i < 5; i++) {
printf("%d ", myArray[i]);
}
7. Dynamic Arrays: In C, you can also
create dynamic arrays whose size can be determined at runtime using pointers
and memory allocation functions like `malloc` and `free`.
For
example:
int* dynamicArray = NULL;
int size = 10; // Size determined
at runtime
dynamicArray = (int*)malloc(size *
sizeof(int));
// Don't forget to free the memory
when done
free(dynamicArray);
Remember to handle memory
allocation and deallocation properly when working with dynamic arrays to avoid
memory leaks.
These are the basics of working
with integer arrays in C. Arrays are a fundamental data structure in C, and
they provide a convenient way to store and manipulate collections of integers
or other data types.
Example:
-
int numbers[5]; // Declares an
integer array named "numbers" that can hold 5 integers.
2. Character Array (String):
Example: -
char name[20]; // Declares a character array named
"name" that can hold up to 20 characters (including the null
terminator).
In C, a character array is often used to represent strings.
Strings in C are essentially arrays of characters terminated by a null character
(`'\0'`), which marks the end of the string. You can declare and manipulate
character arrays to work with strings in C. Here's how to do it:
1.
Declaration: To
declare a character array (string), you need to specify the data type as
`char`, provide a name for the array, and allocate enough space for the
characters in the string, including the null terminator.
For example:
char
myString[20]; // Declares a character array with space for 19 characters plus
the null terminator
2. Initialization: You can initialize a
character array at the time of declaration or later by assigning a string
literal or by copying characters into it. Here's an example of initialization
during declaration:
char greeting[] = "Hello,
World!";
Or, you can initialize it with a
string later:
char myString[20];
strcpy(myString, "Hello,
World!"); // Copy the string into myString
3.
Accessing and Modifying Characters:
You can access and modify individual characters within a character
array just like with any other array.
For
example:
char firstChar = myString[0]; //
Access the first character ('H')
myString[7] = 'M'; // Modify the
eighth character to 'M'
4. String Functions: C provides a set of
standard string manipulation functions defined in the `<string.h>`
library for working with character arrays (strings). Some commonly used string
functions include:
-
`strlen`: Returns the length of a
string.
-
`strcpy`: Copies one string to
another.
-
`strcat`: Concatenates (appends) one
string to another.
-
`strcmp`: Compares two strings.
-
`strncpy`: Copies a specific number
of characters from one string to another.
Here's an example of using `strlen` to find the length of a
string:
#include <stdio.h>
#include <string.h>
int main() {
char myString[] = "Hello,
World!";
int length = strlen(myString);
printf("Length of the string:
%d\n", length);
return 0;
}
5.
Input and Output: You
can use functions like `printf` and `scanf` for input and output of strings.
For example:
char name[50];
printf("Enter your name:
");
scanf("%s", name);
printf("Hello, %s!\n",
name);
Be cautious when using `scanf` to
read strings to prevent buffer overflow issues. It's often safer to use
functions like `fgets` for input, which allows you to specify a maximum number
of characters to read.
Character arrays (strings) are
fundamental in C and are used extensively for working with text and character
data.
3. Floating-Point Array: A floating-point array is a data
structure that stores a collection of floating-point values (real numbers) in
contiguous memory locations. You can declare and manipulate floating-point
arrays similarly to integer arrays. Here's how you can work with floating-point
arrays in C:
Example:
-
float temperatures[10]; // Declares
a floating-point array named "temperatures" that can hold 10
floating-point values.
4. Array Initialization:
Example:
-
int days_of_week[7] = {1, 2, 3, 4,
5, 6, 7}; // Initializes an integer array with values.
5. Multidimensional Array:
Example: -
int matrix[3][3]; // Declares a 2D integer array with 3 rows
and 3 columns.
Types of Arrays:
1. One-Dimensional
Array: A one-dimensional array in C is a data structure that stores
a collection of elements of the same data type in a linear sequence. Each
element in the array is accessed using an index, which starts from 0 for the
first element and goes up to one less than the size of the array.
One-dimensional arrays are a fundamental concept in C programming and are used
for various purposes.
Syntax:
int scores[5]; // A one-dimensional array
of integers.
Example :
#include <stdio.h>
int main() {
// Declare and initialize a one-dimensional integer array
int myArray[5]; // This array can hold 5 integers
// Initialize the elements of the array
myArray[0] = 10;
myArray[1] = 20;
myArray[2] = 30;
myArray[3] = 40;
myArray[4] = 50;
// Access and print elements of the array
printf("Element
at index 0: %d\n", myArray[0]);
printf("Element at index 1: %d\n", myArray[1]);
printf("Element at index 2: %d\n", myArray[2]);
printf("Element at index 3: %d\n", myArray[3]);
printf("Element at index 4: %d\n", myArray[4]);
return 0;
}
2. Two-Dimensional Array: In C, a
two-dimensional array is a data structure that allows you to store elements in
a grid-like fashion, organized in rows and columns. It's essentially an array
of arrays, where each element is identified by two indices: one for the row and
one for the column. Two-dimensional arrays are commonly used to represent
matrices, tables, grids, and other data structures that have a two-dimensional
structure.
Syntax:
-
int matrix[3][3]; // A
two-dimensional array of integers.
Here's
an example of declaring, initializing, and using a two-dimensional integer
array in C:
#include <stdio.h>
int main() {
// Declare and initialize a 2D integer array
int matrix[3][4] = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};
// Access and print elements of the 2D array
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 4; j++) {
printf("matrix[%d][%d] =
%d\n", i, j, matrix[i][j]);
}
}
return 0;
}
3. Multidimensional Array:
Multidimensional array in C is an array of arrays. It is a data structure that
allows you to store data in a tabular format with multiple dimensions. In C,
you can create multidimensional arrays by defining the size of each dimension.
The most common multidimensional array is a two-dimensional array, which can be
thought of as a grid or matrix.
Syntax:
int data[2][3][4];
// A three-dimensional array of integers.
Example :
#include
<stdio.h>
int main() {
// Declare a 2D array with 3 rows and 4
columns
int matrix[3][4];
// Initialize the elements of the array
int count = 1;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 4; j++) {
matrix[i][j] = count;
count++;
}
}
// Access and print the elements of the
array
printf("Matrix elements:\n");
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 4; j++) {
printf("%3d ",
matrix[i][j]);
}
printf("\n");
}
return 0;
}
Output :
Matrix elements:
1
2 3 4
5
6 7 8
9
10 11 12
4. Dynamic Array: A dynamic array in
C is a data structure that allows you to create an array whose size can change
dynamically during runtime. Unlike static arrays in C, which have a fixed size
that must be determined at compile time, dynamic arrays can grow or shrink as
needed. Dynamic arrays are typically implemented using pointers and memory
allocation functions like malloc() and realloc().
Syntax:
int *dynamic_array = (int
*)malloc(5 * sizeof(int)); // Creates a dynamically allocated integer array.
Example:
#include <stdio.h>
#include <stdlib.h>
int main() {
int *dynamicArray = NULL; // Declare a pointer to an int (the dynamic
array)
int capacity = 0; // The
current capacity of the dynamic array
int size = 0; // The
current number of elements in the dynamic array
// Let's add some elements to the dynamic array
int elementToAdd = 5;
// Check if the dynamic array needs to be resized
if (size >= capacity) {
// Double the capacity (you can choose
any resizing strategy)
capacity = (capacity == 0) ? 1 :
capacity * 2;
// Allocate memory for the resized
dynamic array
int *newArray = (int *)malloc(capacity
* sizeof(int));
if (newArray == NULL) {
printf("Memory allocation
failed\n");
return 1; // Exit with an error
code
}
// Copy the elements from the old array
to the new array
for (int i = 0; i < size; i++) {
newArray[i] = dynamicArray[i];
}
// Free the memory occupied by the old
array
free(dynamicArray);
// Update the pointer to point to the
new array
dynamicArray = newArray;
}
// Add the new element to the dynamic array
dynamicArray[size] = elementToAdd;
size++;
// Access elements in the dynamic array
for (int i = 0; i < size; i++) {
printf("%d ",
dynamicArray[i]);
}
// Free the memory when you're done with the dynamic array
free(dynamicArray);
return 0; // Exit successfully
}
5. String (Character Array): a string is represented
as an array of characters, often referred to as a character array. Strings in C
are null-terminated, meaning they end with a null character '\0' to indicate
the end of the string. Here's a description of strings in C.
Syntax:
-
char greeting[] = "Hello,
World!"; // A character array to store a string.
Example
:
#include <stdio.h>
int main() {
// Declaring and initializing a character array (string)
char myString[] = "Hello, World!"; // Automatically includes
the null terminator
// Accessing and printing a string
printf("String: %s\n", myString);
// Finding the length of a string (excluding the null terminator)
int length = 0;
while (myString[length] != '\0') {
length++;
}
printf("Length of the string: %d\n", length);
// Modifying a string
myString[7] = 'G'; // Change 'W' to 'G'
printf("Modified string: %s\n", myString);
return 0;
}
6.
Jagged Array: a
jagged array is an array of arrays where each element of the outer array points
to another array of potentially different sizes. Unlike a 2D array (also known
as a rectangular array), where all rows have the same number of columns, jagged
arrays allow for more flexible storage of data where each row can have a different
number of columns. Jagged arrays are often used when you need to represent data
with irregular or varying dimensions.
Syntax: -
int jagged_array[][3] = {{1, 2, 3},
{4, 5}, {6, 7, 8, 9}}; // A jagged array of integers.
Example :
#include <stdio.h>
#include <stdlib.h>
int main() {
// Declare and initialize a jagged array of integers
int *jaggedArray[3]; // An array of integer pointers
// Initialize the individual arrays with different sizes
int row1[] = {1, 2, 3};
int row2[] = {4, 5};
int row3[] = {6, 7, 8, 9};
// Assign the arrays to the jagged array
jaggedArray[0] = row1;
jaggedArray[1] = row2;
jaggedArray[2] = row3;
// Access and print elements of the jagged array
for (int i = 0; i < 3; i++) {
int *currentRow = jaggedArray[i];
int rowSize = sizeof(currentRow) /
sizeof(currentRow[0]);
printf("Row %d: ", i);
for (int j = 0; j < rowSize; j++) {
printf("%d ",
currentRow[j]);
}
printf("\n");
}
return 0;
}
These are some common types of
arrays in C, each with its own use cases and characteristics. Arrays are
fundamental data structures in C and play a crucial role in many programming
tasks.
Comments
Post a Comment