Atribuir Memória Estrutural Com malloc em C
-
Use
malloc
com o operadorsizeof
para alocar memória estrutural em C -
Use o loop
for
para alocar memória para un array de estruturas em C
![Atribuir Memória Estrutural Com malloc em C](/img/C/feature-image---c-malloc-struct.webp)
Este artigo explicará vários métodos de como alocar memória estrutural com malloc
em C.
Use malloc
com o operador sizeof
para alocar memória estrutural em C
malloc
é a função central da alocação dinâmica de memória em C, que requer um único argumento inteiro representando o número de bytes a serem alocados. Para alocar a memória do objecto personalizado struct
que foi definido, devemos chamar o sizeof
operador e recuperar a quantidade de memória que o objecto precisa de ser armazenada.
Note-se que podemos passar a expressão sizeof(MyObject)
directamente para a chamada malloc
como argumento. Uma advertência sobre o malloc
é que a memória atribuída com sucesso não é inicializada, o que significa que pode haver alguns valores de lixo armazenados. Para contrariar esta questão, a biblioteca C fornece outra função útil - calloc
para inicializar automaticamente a região de memória com zero. O exemplo seguinte mostra a alocação de memória para a estrutura única MyObject
.
#include <stdio.h>
#include <stdlib.h>
enum VALID { FALSE, TRUE };
typedef struct {
int valid;
int *data;
size_t size;
} MyObject;
int main() {
int *tmp = NULL;
MyObject *my1 = malloc(sizeof(MyObject));
my1->valid = TRUE;
my1->data = tmp;
my1->size = sizeof tmp;
free(my1);
exit(EXIT_SUCCESS);
}
Use o loop for
para alocar memória para un array de estruturas em C
É frequentemente útil declarar um array de estruturas, que podem exigir uma região de memória maior do que a disponível na pilha. Assim, precisamos de alocar a matriz como memória dinâmica. O seguinte código de exemplo demonstra o caso quando o array de 100 apontadores para as estruturas MyObject
é declarado na pilha, mas cada objecto individual MyObject
é atribuído na memória dinâmica (pilha).
Note-se que também implementámos a função initMyObject
para inicializar cada membro no MyObject
apenas para fins de teste. A função retorna -1
se o ponteiro passado for null
, e a declaração if
é colocada no laço for
para garantir que a mensagem de erro correspondente é impressa.
#include <stdio.h>
#include <stdlib.h>
#define MAX 100
enum VALID { FALSE, TRUE };
typedef struct {
int valid;
int *data;
size_t size;
} MyObject;
int initMyObject(MyObject *obj, int val, int *dat, size_t siz) {
if (!obj) return -1;
obj->valid = val;
obj->data = dat;
obj->size = siz;
return 0;
}
int main() {
int *tmp = NULL;
MyObject *arr[MAX];
for (int i = 0; i < MAX; ++i) {
arr[i] = malloc(sizeof(MyObject));
if (initMyObject(arr[i], TRUE, tmp, sizeof(tmp)) == -1) {
fprintf(stderr, "[ERROR] initMyObject() failed\n");
break;
}
}
printf("finished\n");
exit(EXIT_SUCCESS);
}
Embora haja uma parte errada do programa anterior que não pode ser permitida em qualquer código de produção. O programa sai sem desalocar regiões de memória que tenham sido atribuídas dinamicamente no laço. Note-se que, à semelhança da atribuição, cada elemento individual do array deve ser libertado. Assim, implementámos uma função separada, deallocMyObjectArray
, para executar chamadas iterativas para free
na seguinte amostra de código.
#include <stdio.h>
#include <stdlib.h>
#define MAX 100
enum VALID { FALSE, TRUE };
typedef struct {
int valid;
int *data;
size_t size;
} MyObject;
int initMyObject(MyObject *obj, int val, int *dat, size_t siz) {
if (!obj) return -1;
obj->valid = val;
obj->data = dat;
obj->size = siz;
return 0;
}
int deallocMyObjectArray(MyObject *arr[], size_t len) {
if (!arr) return -1;
for (int i = 0; i < len; ++i) free(arr[i]);
return 0;
}
int main() {
int *tmp = NULL;
MyObject *arr[MAX];
for (int i = 0; i < MAX; ++i) {
arr[i] = malloc(sizeof(MyObject));
if (initMyObject(arr[i], TRUE, tmp, sizeof(tmp)) == -1) {
fprintf(stderr, "[ERROR] initMyObject() failed\n");
break;
}
}
deallocMyObjectArray(arr, MAX);
printf("finished\n");
exit(EXIT_SUCCESS);
}
Founder of DelftStack.com. Jinku has worked in the robotics and automotive industries for over 8 years. He sharpened his coding skills when he needed to do the automatic testing, data collection from remote servers and report creation from the endurance test. He is from an electrical/electronics engineering background but has expanded his interest to embedded electronics, embedded programming and front-/back-end programming.
LinkedIn Facebook