Re: No casting of void* ???

Hello,

Okay, I seem to have accomplished a solution that compiles and satisfies the
usage of a single function to replace other identical ones. I pretty much
used alot of the feedback you guys gave me in the previous post.

There's one thing though, you see, the whole objective of my tables at the
top of any of my windProc functions is so the programmer can fill out the
informations he desires for every record. For example if I do this:

============================================
void wndProc1()
{
// declare a pc pointer
pc *a;

// Fill 2 records
pc_table apc[] = {
0, 0, 100, 10,
1, 0, 150, 11};

============================================

means that the first two fields for every record in the apc array depict the
identification links that correspond to the rest of the record. So for
example, if another window procedure sends two global variables identifying
the linking fields as 1 and 0, then this wndProc will compare these fields to
a matching record in the apc array! That's basically what the
lb_match_link_id() function I showed Igor does... well actually it would also
return the record's location in the array and then beased on the record's
location I would use the rest of the data in this record for other
functionality to the control.

Having said, this, to create base structures so to condense identical
structure elements into one structure causes me to loose out on the
compactability of the table configuartion shown above. Basically, now, the
table would have to be fragmented in two structures. I am not saying that
base structures are no good, all I am saying is that it was nice to just have
the linking ID fields embeded in its associated record right then and there.
And perhaps, I am wrong in thinking in this methodological way. I just seemed
to find it convenient.

Is it that I shoud get used to seperating data at the expense of creating
more structures and leaving behind the fact that now instead of filling out
one table, I would have to fill two of them.... (as shown in sample below)
then if so, then okay, I will have to change my habits.

Here is what I have come up with... mostly done with base structures!

============================================
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// BASE TABLE
typedef struct tag_table_links
{
long LK__F1;
long LK__F2;
}table_links;

// TABLES
typedef struct tag_pc_table
{
long j;
int y;
}pc_table;

typedef struct tag_lb_table
{
long r;
char s[10];
}lb_table;

// BASE OBJECT
typedef struct tag_obj_links {
struct tag_table_links *dc;
} obj_links;

typedef struct tag_pc {
int i;
} pc;

typedef struct tag_lb {
char s[10];
} lb;

// common code Function!
void f1(obj_links *o, table_links *x)
{
if(o->dc->LK__F1 == x->LK__F1)
{
// then do something....
}
}

void wndProc1()
{
// declare a pc pointer
pc *a;

// Declare an object_links object to hold incoming links
obj_links *ol = NULL;

// Data links desired from previous control
// (1,0) targets the second apc record!
long Link_Id1_from_Previous_WndProc = 1;
long Link_Id2_from_Previous_WndProc = 0;

// Programmer configures respective links that coresponding
// to the 2 apc records in the pc_table
table_links atl[] = {
0, 0,
1, 0};

// Fill 2 records
pc_table apc[] = {
100, 10,
150, 11};

// Assign the links to a base struct
ol->dc->LK__F1 = Link_Id1_from_Previous_WndProc;
ol->dc->LK__F2 = Link_Id2_from_Previous_WndProc;

// create object
a = (pc*) malloc(sizeof (struct tag_pc));
// Fill out the object's data members

a->i = 10;
// Now! I can use a common function to do stuff
f1(ol, atl);

free(a);
}

void wndProc2()
{
// declare an lb pointer
lb *b;

// Declare an object_links object to hold incoming links
obj_links *ol = NULL;

// Data links desired from previous control
long Link_Id1_from_Another_WndProc = 5;
long Link_Id2_from_Another_WndProc = 2;

// Programmer configures respective links that coresponding
// to the 5 alb records in the lb_table
table_links atl[] = {
{0, 0},
{1, 0},
{1, 1},
{5, 2},
{5, 3},};

// Fill 5 records
lb_table alb[] = {
500, "structs",
188, "pointers",
468, "code",
89, "prog",
333, "list",};

// Assign the links to a base struct
ol->dc->LK__F1 = Link_Id1_from_Another_WndProc;
ol->dc->LK__F2 = Link_Id2_from_Another_WndProc;

// create object
b = (lb*) malloc(sizeof (struct tag_lb));

// Fill out the object's data members
strcpy_s(b->s, "abc");

// Now! I can use a common function to do stuff
f1(ol, atl);

free(b);
}

int main()
{
wndProc1();
wndProc2();
return 0;
}
========================================

Okay, soryy for the long sample code, but it was necessary to show how the
f1() function works out.

Link_Id1_from_Previous_WndProc and Link_Id2_from_Previous_WndProc variables
are really global variables that would be set by some other WndProc, I just
put them local here just for the sample's purpose.

Is the above code acceptable as an object configuration technique?

All feedback regrading my posts is well appreciated guys!

--
Best regards
Roberto

"Robby" wrote: