Dado que C es un lenguaje estructurado, tiene algunas reglas fijas para la programación. Uno de ellos incluye cambiar el tamaño de una array. Una array es una colección de elementos almacenados en ubicaciones de memoria contiguas.
Como se puede ver, la longitud (tamaño) de la array anterior es 9. Pero, ¿qué pasa si hay un requisito para cambiar esta longitud (tamaño)? Por ejemplo,
- Si hay una situación en la que solo se necesitan 5 elementos para ingresar en esta array. En este caso, los 4 índices restantes solo desperdician memoria en esta array. Por lo tanto, existe el requisito de reducir la longitud (tamaño) de la array de 9 a 5.
- Tome otra situación. En esto, hay una array de 9 elementos con los 9 índices llenos. Pero es necesario ingresar 3 elementos más en esta array. En este caso, se requieren 3 índices más. Entonces, la longitud (tamaño) de la array debe cambiarse de 9 a 12.
Este procedimiento se conoce como Asignación dinámica de memoria en C . Por lo tanto, la asignación de memoria dinámica
de C se puede definir como un procedimiento en el que el tamaño de una estructura de datos (como Array) se cambia durante el tiempo de ejecución. C proporciona algunas funciones para lograr estas tareas. Hay 4 funciones de biblioteca proporcionadas por C definidas en el archivo de encabezado <stdlib.h> para facilitar la asignación de memoria dinámica en la programación de C. Están:
- malloc()
- llamar()
- libre()
- reasignar()
Veamos cada uno de ellos con mayor detalle.
Método C malloc()
El método «malloc» o «asignación de memoria» en C se usa para asignar dinámicamente un solo bloque grande de memoria con el tamaño especificado. Devuelve un puntero de tipo void que se puede convertir en un puntero de cualquier forma. No inicializa la memoria en el momento de la ejecución, por lo que inicialmente ha inicializado cada bloque con el valor de basura predeterminado.
Sintaxis:
ptr = (cast-type*) malloc(byte-size) For Example:
ptr = (int*) malloc(100 * tamaño(int));
Dado que el tamaño de int es de 4 bytes, esta declaración asignará 400 bytes de memoria. Y, el puntero ptr contiene la dirección del primer byte en la memoria asignada.
Si el espacio es insuficiente, la asignación falla y devuelve un puntero NULL.
Ejemplo:
C
#include <stdio.h>
#include <stdlib.h>
int main()
{
// This pointer will hold the
// base address of the block created
int* ptr;
int n, i;
// Get the number of elements for the array
printf("Enter number of elements:");
scanf("%d",&n);
printf("Entered number of elements: %d\n", n);
// Dynamically allocate memory using malloc()
ptr = (int*)malloc(n * sizeof(int));
// Check if the memory has been successfully
// allocated by malloc or not
if (ptr == NULL) {
printf("Memory not allocated.\n");
exit(0);
}
else {
// Memory has been successfully allocated
printf("Memory successfully allocated using malloc.\n");
// Get the elements of the array
for (i = 0; i < n; ++i) {
ptr[i] = i + 1;
}
// Print the elements of the array
printf("The elements of the array are: ");
for (i = 0; i < n; ++i) {
printf("%d, ", ptr[i]);
}
}
return 0;
}
Enter number of elements: 5 Memory successfully allocated using malloc. The elements of the array are: 1, 2, 3, 4, 5,
método C calloc()
- El método «calloc» o «asignación contigua» en C se usa para asignar dinámicamente el número especificado de bloques de memoria del tipo especificado. es muy similar a malloc() pero tiene dos puntos diferentes y estos son:
- Inicializa cada bloque con un valor predeterminado ‘0’.
- Tiene dos parámetros o argumentos en comparación con malloc().
Sintaxis:
ptr = (cast-type*)calloc(n, element-size); here, n is the no. of elements and element-size is the size of each element.
Por ejemplo:
ptr = (flotante*) calloc(25, tamaño de(flotante));
Esta declaración asigna espacio contiguo en la memoria para 25 elementos, cada uno con el tamaño del flotador.
Si el espacio es insuficiente, la asignación falla y devuelve un puntero NULL.
Ejemplo:
C
#include <stdio.h>
#include <stdlib.h>
int main()
{
// This pointer will hold the
// base address of the block created
int* ptr;
int n, i;
// Get the number of elements for the array
n = 5;
printf("Enter number of elements: %d\n", n);
// Dynamically allocate memory using calloc()
ptr = (int*)calloc(n, sizeof(int));
// Check if the memory has been successfully
// allocated by calloc or not
if (ptr == NULL) {
printf("Memory not allocated.\n");
exit(0);
}
else {
// Memory has been successfully allocated
printf("Memory successfully allocated using calloc.\n");
// Get the elements of the array
for (i = 0; i < n; ++i) {
ptr[i] = i + 1;
}
// Print the elements of the array
printf("The elements of the array are: ");
for (i = 0; i < n; ++i) {
printf("%d, ", ptr[i]);
}
}
return 0;
}
Enter number of elements: 5 Memory successfully allocated using calloc. The elements of the array are: 1, 2, 3, 4, 5,
método C libre()
El método «libre» en C se usa para desasignar dinámicamente la memoria. La memoria asignada mediante las funciones malloc() y calloc() no se desasigna por sí sola. Por lo tanto, se usa el método free() siempre que se lleva a cabo la asignación de memoria dinámica. Ayuda a reducir el desperdicio de memoria al liberarla.
Sintaxis:
free(ptr);
Ejemplo:
C
#include <stdio.h>
#include <stdlib.h>
int main()
{
// This pointer will hold the
// base address of the block created
int *ptr, *ptr1;
int n, i;
// Get the number of elements for the array
n = 5;
printf("Enter number of elements: %d\n", n);
// Dynamically allocate memory using malloc()
ptr = (int*)malloc(n * sizeof(int));
// Dynamically allocate memory using calloc()
ptr1 = (int*)calloc(n, sizeof(int));
// Check if the memory has been successfully
// allocated by malloc or not
if (ptr == NULL || ptr1 == NULL) {
printf("Memory not allocated.\n");
exit(0);
}
else {
// Memory has been successfully allocated
printf("Memory successfully allocated using malloc.\n");
// Free the memory
free(ptr);
printf("Malloc Memory successfully freed.\n");
// Memory has been successfully allocated
printf("\nMemory successfully allocated using calloc.\n");
// Free the memory
free(ptr1);
printf("Calloc Memory successfully freed.\n");
}
return 0;
}
Enter number of elements: 5 Memory successfully allocated using malloc. Malloc Memory successfully freed. Memory successfully allocated using calloc. Calloc Memory successfully freed.
Método C realloc()
El método de «reasignación» o «reasignación» en C se usa para cambiar dinámicamente la asignación de memoria de una memoria previamente asignada. En otras palabras, si la memoria previamente asignada con la ayuda de malloc o calloc es insuficiente, se puede usar realloc para reasignar memoria dinámicamente . la reasignación de memoria mantiene el valor ya presente y los nuevos bloques se inicializarán con el valor de basura predeterminado.
Sintaxis:
ptr = realloc(ptr, newSize); where ptr is reallocated with new size 'newSize'.
Si el espacio es insuficiente, la asignación falla y devuelve un puntero NULL.
Ejemplo:
C
#include <stdio.h>
#include <stdlib.h>
int main()
{
// This pointer will hold the
// base address of the block created
int* ptr;
int n, i;
// Get the number of elements for the array
n = 5;
printf("Enter number of elements: %d\n", n);
// Dynamically allocate memory using calloc()
ptr = (int*)calloc(n, sizeof(int));
// Check if the memory has been successfully
// allocated by malloc or not
if (ptr == NULL) {
printf("Memory not allocated.\n");
exit(0);
}
else {
// Memory has been successfully allocated
printf("Memory successfully allocated using calloc.\n");
// Get the elements of the array
for (i = 0; i < n; ++i) {
ptr[i] = i + 1;
}
// Print the elements of the array
printf("The elements of the array are: ");
for (i = 0; i < n; ++i) {
printf("%d, ", ptr[i]);
}
// Get the new size for the array
n = 10;
printf("\n\nEnter the new size of the array: %d\n", n);
// Dynamically re-allocate memory using realloc()
ptr = realloc(ptr, n * sizeof(int));
// Memory has been successfully allocated
printf("Memory successfully re-allocated using realloc.\n");
// Get the new elements of the array
for (i = 5; i < n; ++i) {
ptr[i] = i + 1;
}
// Print the elements of the array
printf("The elements of the array are: ");
for (i = 0; i < n; ++i) {
printf("%d, ", ptr[i]);
}
free(ptr);
}
return 0;
}
Enter number of elements: 5 Memory successfully allocated using calloc. The elements of the array are: 1, 2, 3, 4, 5, Enter the new size of the array: 10 Memory successfully re-allocated using realloc. The elements of the array are: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
Otro ejemplo para el método realloc() es:
C
#include <stdio.h>
#include <stdlib.h>
int main()
{
int index = 0, i = 0, n,
*marks; // this marks pointer hold the base address
// of the block created
int ans;
marks = (int*)malloc(sizeof(
int)); // dynamically allocate memory using malloc
// check if the memory is successfully allocated by
// malloc or not?
if (marks == NULL) {
printf("memory cannot be allocated");
}
else {
// memory has successfully allocated
printf("Memory has been successfully allocated by "
"using malloc\n");
printf("\n marks = %pc\n",
marks); // print the base or beginning
// address of allocated memory
do {
printf("\n Enter Marks\n");
scanf("%d", &marks[index]); // Get the marks
printf("would you like to add more(1/0): ");
scanf("%d", &ans);
if (ans == 1) {
index++;
marks = (int*)realloc(
marks,
(index + 1)
* sizeof(
int)); // Dynamically reallocate
// memory by using realloc
// check if the memory is successfully
// allocated by realloc or not?
if (marks == NULL) {
printf("memory cannot be allocated");
}
else {
printf("Memory has been successfully "
"reallocated using realloc:\n");
printf(
"\n base address of marks are:%pc",
marks); ////print the base or
///beginning address of
///allocated memory
}
}
} while (ans == 1);
// print the marks of the students
for (i = 0; i <= index; i++) {
printf("marks of students %d are: %d\n ", i,
marks[i]);
}
free(marks);
}
return 0;
}
Producción:
Publicación traducida automáticamente
Artículo escrito por RishabhPrabhu y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA