Using C Dynamic allocation using malloc and realloc - c

Question

I am having some trouble using the malloc and realloc functions in C and saving values in them using 2 seperate functions
Note i have only recently just started using c and porbably there are multiple bugs in the code but my main focus is saving the values to the struct
i need to be able to save multiple values to a single array.
these are my functions
int ArrayCreate() {
int *pt;
pt = (ASet *)calloc(1,sizeof(ASet));
pt == NULL;
return *pt;
}
//possible 2nd *
void ArrayAdd(ASet **arrayStruct, int x) {
ASet *pt = NULL;
*arrayStruct=realloc(*arrayStruct,1*sizeof(ASet));
pt = arrayStruct;
*arrayStruct->value = x;
free(pt);
}
and in my main i have
ASet *arr_pt = NULL;
to create an array
printf("a new array is created \n");
arr_pt = ArrayCreate();
break;
to add something to an array
printf("Enter integer \n");
scanf("%d",&x);
ArrayAdd(arr_pt,x);
while (getchar() != '\n') {
continue;
}
break;
also to test i have added this but i am not sure about it
void ArrayShow(ASet *arrayStruct) {
ASet *pt = arrayStruct;
//printf("%d \n", pt[0].value);
printf("%d \n", pt[1].value);
printf("%d \n", pt[2].value);
printf("%d \n", pt[3].value);
printf("%d \n", pt[4].value);
}
i only need to know how to save correctly using realloc and calloc but for some reason the pt[0] is ignored and anything after p[1] is garbage

Answer 1

simple sample
#include <stdio.h>
#include <stdlib.h>
typedef int Item;
#define PRN_Item "%d"
typedef struct da {
size_t size;
Item *value;
} ASet;
ASet *ArrayCreate(void){
return calloc(1, sizeof(ASet));
}
void ArrayAdd(ASet *arrayStruct, Item x){
ASet *ap = arrayStruct;
Item *p = ap->value;
p = realloc(p, (ap->size + 1)*sizeof(Item));
if(p){
ap->value = p;
ap->value[ap->size] = x;
ap->size += 1;
} else {
perror("realloc");
exit(1);
}
}
void ArrayShow(ASet *arrayStruct) {
Item *v = arrayStruct->value;
size_t n = arrayStruct->size;
while(n--){
printf(PRN_Item " \n", *v++);
}
}
void ArrayDrop(ASet *arrayStruct){
free(arrayStruct->value);
free(arrayStruct);
}
int main(){
ASet *arr_pt = ArrayCreate();
if(!arr_pt){
perror("ArrayCreate");
exit(1);
}
printf("a new array is created \n");
while(1){
int x;
printf("Enter integer \n");
if(1!=scanf("%d", &x))
break;
ArrayAdd(arr_pt, x);
}
ArrayShow(arr_pt);
ArrayDrop(arr_pt);
return 0;
}

Answer 2

EDIT:
The line below is a comment so it's not executed:
//printf("%d \n", pt[0].value);
And your casting to pt with the wrong type that's why you're getting garbage
/* replace Aset with int and SIZE must be a defined size */
pt= calloc(SIZE, sizeof(int));
pt == NULL is a comparaison expression not an assingment statment:
pt = NULL // assining NULL to pt
ArrayCreate must return a pointer to the fisrt element of the array, not the value of the address pointed to:
int *ArrayCreate() {
int *pt;
pt = calloc(SIZE,sizeof(int));
pt == NULL;
return pt;
}

Answer 3

there are a few things wrong with your code here are some:
instead of pt == NULL; you should do pt = NULL because using the first compares between pt and NULL and doesn't assign NULL to pt
this pt = arrayStruct is illegal because pt is of type ASet while arrayStruct is of type **ASet you should replace it with pt = *arrayStruct
here *arrayStruct->value = x; it's like you're asking for the address of the member value to be changed to x you should instead do *(arrayStruct)->value = x;

Answer 4

Problems:
There's no visible record of how big the array is, so you can't tell what size to reallocate.
Your ArrayCreate() function should return a pointer to the structure. The pt == NULL; statement does nothing; your compiler should be warning you about a statement with no effect. Because you are returning an int and not a pointer, you are leaking memory.
Your ArrayAdd() function doesn't know how much space to allocate (point 1 again). The code should not be using free(pt); realloc() may have returned a pointer to the same location or to a different location, but either way, it has dealt with the old memory.
I did not understand the 1, 2; so you're saying pt should be *pt? What effect will that have and 3 the part about how much space?
Consider the ArrayCreate() function — as currently written:
int ArrayCreate() {
int *pt;
pt = (ASet *)calloc(1,sizeof(ASet));
pt == NULL;
return *pt;
}
First of all, the code is confused about whether it is dealing with int or ASet types. It appears to be allocating an array with 1 (zeroed) ASet element but assigning that to an int *. The next line should probably be an if statement. The code should probably read:
ASet *ArrayCreate(void)
{
ASet *pt = (ASet *)calloc(1, sizeof(ASet));
if (pt == NULL)
{
fprintf(stderr, "Memory allocation failed!\n");
exit(1);
}
return pt;
}
I don't object to the cast on the return from calloc() as long as you reassure me that you always compile with options such that if you forget to include <stdlib.h>, your code will not compile. For example, I mainly use GCC and always compile with options such as:
gcc -O3 -g -std=c11 -Wall -Wextra -Wmissing-prototypes -Wstrict-prototypes -Wold-style-definition -Werror ...
If you don't compile like that, then you're better off omitting the cast. As you'll notice, there are others who are not as flexible about the issue of casting the return from malloc() et al. (I even use those options on other people's code on SO; it is sometimes painful getting their code to compile cleanly.)
The error handling or memory allocation is about the simplest available option — report the error (on standard error, be it noted) and exit. You can be as creative as you like about how to handle the error, but failing fast has many merits in many situations.
Now, the code I've shown is more or less coherent, but the only way you know that there's one element in the array of ASet values is ... because it was just created with one element.
When you call ArrayAdd() the first time, you can assume that there was one element in the array, but when you call it another time, you have no idea how many rows are in the array, so you'll still allocate 2 elements to the array, even though that's a no-op. You need to know, somehow, how many elements are already in the array.
As currently written:
void ArrayAdd(ASet **arrayStruct, int x) {
ASet *pt = NULL;
*arrayStruct=realloc(*arrayStruct,1*sizeof(ASet));
pt = arrayStruct;
*arrayStruct->value = x;
free(pt);
}
You take the (pointer to the) array that you're passed, and resize the array to one element. The pt = arrayStruct; line should generate compilation warnings; you're assigning an ASet ** to an ASet *; they're very different types. The free(pt) is simply wrong — irredeemably wrong. You need code something like:
void ArrayAdd(ASet **arrayStruct, size_t new_size, int x)
{
ASet *pt = realloc(*arrayStruct, new_size * sizeof(ASet));
if (pt == 0)
{
fprintf(stderr, "Memory allocation failed!\n");
exit(1);
}
pt[new_size-1].value = x;
*arrayStruct = pt;
}
Again the code fails fast on memory allocation failure. It is careful not to clobber *arrayStruct before it knows that it is safe to do so. It assigns x to the value member of the last element of the array. Note that realloc() does not zero the extra memory it makes available. The code also does not know how big the array was before; it can't tell whether the array is growing or shrinking — only the calling code is privy to that information.
So, this isn't a very good bit of code, but it is better than what was there before.