How to Alter the Size of an Array in C
Arrays in C are fixed in size once they are declared. This means that you cannot directly change the size of an array after it has been created. However, there are several methods you can use to alter the size of an array in C. In this article, we will discuss some of the common techniques for resizing an array in C, including dynamic memory allocation and copying the elements to a new array.
One of the most common ways to alter the size of an array in C is by using dynamic memory allocation. This involves allocating a new block of memory with the desired size and then copying the elements from the original array to the new block. Here’s an example of how you can do this:
“`c
include
include
int main() {
int originalArray = (int )malloc(5 sizeof(int));
if (originalArray == NULL) {
printf(“Memory allocation failed.”);
return 1;
}
// Initialize the array with some values
for (int i = 0; i < 5; i++) {
originalArray[i] = i;
}
// Resize the array to a new size
int newSize = 10;
int newArray = (int )realloc(originalArray, newSize sizeof(int));
if (newArray == NULL) {
printf("Memory reallocation failed.");
free(originalArray);
return 1;
}
// Copy the elements from the original array to the new array
for (int i = 5; i < newSize; i++) {
newArray[i] = i;
}
// Use the new array as needed
for (int i = 0; i < newSize; i++) {
printf("%d ", newArray[i]);
}
printf("");
// Free the memory allocated for the original array
free(originalArray);
return 0;
}
```
In this example, we first allocate memory for an array of 5 integers using `malloc`. We then initialize the array with some values. Next, we use `realloc` to resize the array to 10 integers. We then copy the elements from the original array to the new array, and finally, we free the memory allocated for the original array.
Another method for altering the size of an array in C is by creating a new array with the desired size and copying the elements from the original array to the new array. Here's an example:
```c
include
include
int main() {
int originalArray[] = {1, 2, 3, 4, 5};
int originalSize = sizeof(originalArray) / sizeof(originalArray[0]);
int newSize = 10;
// Allocate memory for the new array
int newArray = (int )malloc(newSize sizeof(int));
if (newArray == NULL) {
printf(“Memory allocation failed.”);
return 1;
}
// Copy the elements from the original array to the new array
for (int i = 0; i < originalSize; i++) {
newArray[i] = originalArray[i];
}
// Use the new array as needed
for (int i = 0; i < newSize; i++) {
printf("%d ", newArray[i]);
}
printf("");
// Free the memory allocated for the new array
free(newArray);
return 0;
}
```
In this example, we first declare an array with 5 elements. We then calculate the size of the original array and allocate memory for a new array with a size of 10 integers. We copy the elements from the original array to the new array and then use the new array as needed. Finally, we free the memory allocated for the new array.
Both of these methods allow you to alter the size of an array in C. However, it's important to note that these methods can be memory-intensive, especially if the array is large. Always ensure that you free the memory allocated for the original array after you are done using it to avoid memory leaks.
