contenido
1. Características de arreglos flexibles
2. El uso de arreglos flexibles
1. Cómo usar arreglos flexibles
2. ¿Cuál es la alternativa si no necesita una matriz flexible?
3. Ventajas de los arreglos flexibles
1. Características de arreglos flexibles
struct S
{
int x;
int a[];
};
int main()
{
printf("%d", sizeof(S));
}¿Cuál es la salida de este código?
Imprimimos el tamaño del espacio que ocupa la estructura S. ¿Cuántos bytes ocupa este a[]?
El resultado de salida es 4, pero una x de tipo int es 4. ¿Adónde va a[]? Tan raro.
Resulta que esta es una matriz flexible .
1. Se permite que el último elemento de la estructura sea una matriz de tamaño desconocido , que es una matriz flexible .
2. Una matriz flexible en una estructura debe estar precedida por al menos otro miembro.
3. El tamaño de esta estructura devuelta por sizeof no incluye la memoria de la matriz flexible.
4. La estructura que contiene los miembros de la matriz flexible usa la función malloc para asignar memoria dinámicamente , y la memoria asignada debe ser mayor que el tamaño de la estructura para acomodar el tamaño esperado de la matriz flexible.
2. El uso de arreglos flexibles
1. Cómo usar arreglos flexibles
La estructura que contiene los miembros de la matriz suave utiliza la función malloc para asignar memoria dinámicamente ,
Y la memoria asignada debe ser mayor que el tamaño de la estructura para adaptarse al tamaño esperado de la matriz flexible.
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
struct S
{
int x;
int a[];
};
int main()
{
//为柔性数组a[]开辟了40个字节的空间
struct S *ps =(struct S*)malloc(sizeof(struct S) + 40);
if (ps == NULL) //检查是否为空指针
{
perror("ps");
return 1;
}
ps->x = 10;
int i = 0;
for (i = 0; i < 10; i++)
{
ps->a[i] = i; //数组使用
}
for (i = 0; i < 10; i++)
{
printf("%d ",ps->a[i]); //数组打印
}
//若觉得40不够用，可用realloc扩容
//如:
struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 80);
if (ptr == NULL) //检查是否为空指针
{
perror("realloc");
return 1;
}
else
{
ps = ptr;
}
free(ps); //释放内存并置为空指针
ps = NULL;
}2. ¿Cuál es la alternativa si no necesita una matriz flexible?
A menudo usamos punteros de cadena para asignar espacio,
Luego, directamente malloc un espacio para el puntero de cadena, ¿no está bien?
¿Por qué utilizar arreglos flexibles?
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
struct S
{
int x;
int *a;
};
int main()
{
struct S* ps = (struct S*)malloc(sizeof(struct S) );//为结构体变量x开辟空间
if (ps == NULL)
{
return 1;
}
ps->a = (int*)malloc(40); //为字符串指针开辟40个字节的空间
if (ps->a == NULL)
{
free(ps);
ps = NULL;
return 1;
}
free(ps->a);
ps->a = NULL;
free(ps);
ps = NULL;
}El código anterior hace exactamente lo mismo,
Pero las matrices flexibles son relativamente mejores.
Echemos un vistazo a las ventajas de los arreglos flexibles .
3. Ventajas de los arreglos flexibles
1. Conveniente liberación de memoria
Con arreglos flexibles solo usamos gratis una vez,
Sin embargo, el uso de un puntero de cadena requiere liberar dos veces y existe el riesgo de pérdidas de memoria.
2. Mejorar la velocidad de acceso
La matriz flexible se malloca una vez y es memoria contigua ,
Beneficioso para mejorar la velocidad de acceso y reducir la fragmentación de la memoria.