Re: Passing an array of structures from a pointer [3]
Hello Giovanni!
Thanks for your help, I really appreciate it.
Giovanni: here is what you proposed:
========================================
COLL1 * Create_Coll1(void)
{
COLL1 * pColl1 = NULL;
int count = 2;
/* Create collection (array) on the heap */
pColl1 = (COLL1 *) malloc( sizeof(COLL1) * count );
/* Should check for errors - malloc() returning NULL ... */
/* TODO */
/* Initialize the COLL1 array */
pColl1[0].LINK_ID = 200;
pColl1[0].LIST_NUMBER = 4;
pColl1[1].LINK_ID = 201;
pColl1[1].LIST_NUMBER = 8;
/* Return pointer to that array to the caller */
return pColl1;
}
=================================================
The problem is that I may have many items in the DDLB_COLL1[] array. For
example my real ddlbColl1 structure is:
struct ddlbColl1{
long LINK_ID;
short QUIT_FLAG;
long QUESTION;
int Q_MBS;
int Q_MBE;
long DDLB_SELECTED;
long DDLB_TXT1;
long DDLB_TXT2;
long DDLB_TXT3;
long DDLB_TXT4;
long DDLB_TXT5;
int LIST_ID;
int QRSS[3];
int ESST[3];
};
and if I create an array of say 15 or 20 items of this structure, thats
going to mean alot of these:
pColl1[0].LINK_ID = 200;
and also, I might have several structures like ddlbColl1 to choose from. Its
like this, you know your function called "COLL1 * Create_Coll1(void);" well,
instead of void I would pass in an int and put that int in a select/case, and
depending of its value
I will choose the which structure I will use to set up an array of that
structure. So you can imagine all the possibble lines like this:
pColl1[0].LINK_ID = 200;
that I will have to do for every element of every item of every array of
every structure! Am I saying this right? Yeah, well I guess you know what I
mean! And even if I use a for loop for the array of structures every element
in every structure is different, so I still have to innitiate these values in
variables or arrays until I can store them in their respective elements of
every structure of the COLL1 array.
Also, in your function you are returning pColl1, but what happened to my
obj_DDLB pointer I was returning. I was returning this pointer because it
pointed to the ddListBox structure bywhich one of its elements (*xxx)
contained the address of the COLL1 array of structures.
Giovanni, tell me this, Once again, contrary to everything that has been
discussed in the passed posts (unless their would be another way of doing
things), couldn't I just globally define the :
/* Create collection (array) on the heap */
pColl1 = (COLL1 *) malloc( sizeof(COLL1) * count );
and use the pointer as we wish in the function like this:
&pColl1[] = {200, 4, 201, 8};
I guess this looks rediculous! And I guess in C the only way to innitialize
arrays of structures is by doing this right:
COLL1 DDLB_COLL1[] =
{200, 4,
201, 8};
and for this to work I would have to define it globally! But that's no good.
I am exhausted! :)
Look let me know if I am making sence with all this, its like I am running
after my tail!
Thanks again Giovanni for your much valued input, as exhausting this may be
I am still enjoying the discussions and appreciating the help from everyone
here!
--
Best regards
Roberto
"Giovanni Dicanio" wrote:
And you can try this code (which does also the heap allocation):
<code>
#include <stdlib.h>
#include <malloc.h>
typedef struct ddlbColl1{
long LINK_ID;
int LIST_NUMBER;
} COLL1;
typedef struct ddListBox{
int x;
long y;
struct ddlbColl1 *xxx;
} DDLB;
DDLB *obj_DDLB; // Eventually Won't be global!
DDLB* ULC_DDLB_config_ddlb (int x, int y);
void ULC_DDLB_ddlb ( DDLB *obj_DDLB);
void Free_DDLB( DDLB * p );
int main(void)
{
obj_DDLB = ULC_DDLB_config_ddlb (10,5);
ULC_DDLB_ddlb (obj_DDLB);
/* Release memory allocated on the heap */
Free_DDLB( obj_DDLB );
return 0;
}
COLL1 * Create_Coll1(void)
{
COLL1 * pColl1 = NULL;
int count = 2;
/* Create collection (array) on the heap */
pColl1 = (COLL1 *) malloc( sizeof(COLL1) * count );
/* Should check for errors - malloc() returning NULL ... */
/* TODO */
/* Initialize the COLL1 array */
pColl1[0].LINK_ID = 200;
pColl1[0].LIST_NUMBER = 4;
pColl1[1].LINK_ID = 201;
pColl1[1].LIST_NUMBER = 8;
/* Return pointer to that array to the caller */
return pColl1;
}
/* Releases heap memory */
void Free_DDLB( DDLB * p )
{
/* Release memory for pointed array */
if ( p->xxx != NULL )
{
free( p->xxx );
p->xxx = NULL;
}
/* Release memory for structure DDLB */
free( p );
}
DDLB* ULC_DDLB_config_ddlb (int x, int y)
{
obj_DDLB = (DDLB*) malloc (sizeof (struct ddListBox));
obj_DDLB->x = x;
obj_DDLB->y = y;
obj_DDLB->xxx = Create_Coll1(); //Assign the address of the DDLB_COLL1[]
array!
return obj_DDLB;
}
void ULC_DDLB_ddlb ( DDLB *obj_DDLB)
{
// implementation file which uses the infos from DDLB_COLL1 array!
long x;
x = obj_DDLB->xxx[0].LINK_ID; // x = -858993460 ?????
}
</code>
HTH,
Giovanni