Nick said:
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define MAX_STRUCT_SIZE (50)
#define CHAR_ARRAY_SIZE (32)
struct st_Test
{
char szChar[CHAR_ARRAY_SIZE];
int iInt;
void *pVoid;
};
int main(void)
{
/* Pointer to the structure */
struct st_Test *pst_Test = NULL;
char szAny[CHAR_ARRAY_SIZE];
int iCounter;
Since the variable iCounter is being used to keep a count
on a dynamically array of the struct object, I find it
better to encapsulate the pointer to the array along with
the counter in another struct object. See the example below.
This if-else statement is not needed. One feature of function realloc
that you have is that it pst_Test is NULL, which it is in the initialized
state, function realloc behaves like function malloc for the specified
size.
This is a bug but it is harmless. You allocate way too much memory.
It should be:
pst_Test = realloc(pst_Test,
(iCounter*sizeof(void*))+sizeof(struct st_Test));
Both realloc statements are 'buggy'. Should realloc return NULL then
the original allocated space, if any, is now hopelessly lost and
cannot be freed because pst_Test would have the value of NULL. The
realloc statement using 'sizeof((void *)' is allocating the wrong
size space.
// check that malloc\realloc worked
if(!pst_Test) return -1;
/* Add some data to the allocated struct */
pst_Test[iCounter].iInt = iCounter;
What??? pst_Test is not an array! You just want:
pst_Test->iInt = iCounter;
The OP is allocating space for an array of the struct objects.
The [] operator is valid.
Here is an example of what I believe the OP is testing:
a dynamically allocated array of the struct st_Test.
// Test.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct st_Test
{
char szChar[32];
int iInt;
void *pVoid;
}st_Test;
typedef struct st_Array
{
st_Test *pst_Test;
unsigned pst_Count;
}st_Array;
st_Test *addtoArray(st_Array *p, int a);
void printArray(const st_Array *p);
void freeArray(st_Array *p);
int main(void)
{
st_Array test = {NULL,0}; // pointer not valid yet
int i;
for(i = 2222; i < 2232 ;i++)
if(NULL == addtoArray(&test,i))
{
freeArray(&test);
puts("Memory Allocation error");
exit(EXIT_FAILURE);
}
puts("The array contents");
printArray(&test);
freeArray(&test);
return 0;
}
st_Test *addtoArray(st_Array *p,int a)
{
st_Test *temp;
unsigned cnt = p->pst_Count;
temp = realloc(p->pst_Test,(cnt+1)*sizeof(*p->pst_Test));
if(temp == NULL) return NULL;
sprintf(temp[cnt].szChar,"%d",a);
if((temp[cnt].pVoid = malloc(strlen(temp[cnt].szChar)+1)) == NULL)
return NULL;
strcpy(temp[cnt].pVoid,temp[cnt].szChar);
temp[cnt].iInt = a;
p->pst_Test = temp;
p->pst_Count++;
return p->pst_Test;
}
void printArray(const st_Array *p)
{
unsigned i;
for(i = 0; i < p->pst_Count;i++)
printf("\tszChar: %s\n\tiInt: %d\n\tpVoid: %s\n\n",
p->pst_Test
.szChar, p->pst_Test.iInt,
(char *)p->pst_Test.pVoid);
return;
}
void freeArray(st_Array *p)
{
unsigned i;
for(i = 0;i < p->pst_Count;i++)
free(p->pst_Test.pVoid);
free(p->pst_Test);
p->pst_Test = NULL;
p->pst_Count = 0;
}
--
Al Bowers
Tampa, FL. USA
email: (e-mail address removed) (remove the x)
http://www.geocities.com/abowers822
comp.lang.c