No casting of void* ???

Hello again!

Okay, in the previous thread (void* passed as functin parameters) I have
been taugth that:

a) If members in structs are identical, we can make a seperate typedefed
base structure containing the identical members only and access them from
there.

b) The base struct is really not necessary, but it makes the solution more
symmetric between the types.

c) I could use C++ and incorporate templates in my code so we know the type
being pass in before hand so to solve this dilema.

d) Macro functions are interesting, but there is too much to modify in my
current code. I would of had to start doing this from the begining of the
project.

e) Assigning an enum pointer as Uli suggested.

I have played with this and to my surprise I have a code sample version that
works without having done any of the above. I am not critisising anyone's
suggestions here, all your suggestions are valid and you guys did very well
for me and as always and I greatly appreciate it. I just want to dimistify
this so I understand why it works. Its weird, here's the code:

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

// TABLES
typedef struct tag_pc_table
{
long z;
long h;
long j;
}pc_table;

typedef struct tag_lb_table
{
long z;
long h;
int yyy;
}lb_table;

// OBJECTS
typedef struct tag_pc {
long w;
struct tag_pc_table *dc;
} pc;

typedef struct tag_lb {
long w;
struct tag_lb_table *dc;
} lb;

void f1(void *x)
{
pc *p = x;
long t,x;

t = p->dc[0].z;
x = p->dc[0].h;

t->dc[0].z = 998;
x->dc[0].h = 999;
}

int main()
{
long t;
pc *a;
lb *b;

pc_table apc[] = {101, 102}; // Fill one record
lb_table alb[] = {201, 202}; // Fill one record

a = malloc(sizeof (struct tag_pc));
a->dc = apc;
f1(a);

b = malloc(sizeof (struct tag_lb));
b->dc = alb;
f1(b);

t = a->dc[0].z;
t = b->dc[0].h;

free(a); free(b); return 0;
}
====================================

The lines that puzzel me are the following lines in f1():

t = p->dc[0].z;
t = p->dc[0].h;

p->dc[0].z = 998;
p->dc[0].h = 999;

If we pass in the "a" variable to f1() which is a pointer of pc type and we
even further type cast it in f1() with:

pc *p = x;

then, I understand that t and x are equal to 101, 102 respectively as they
get accessed by:

t = p->dc[0].z;
t = p->dc[0].h;

But, if when we pass in the "b" variable to f1() which is a pointer of lb
type and we still cast it in f1() with:

pc *p = x;

and I am stil able to get the correct t and x values as 201, 202
respectively as they get accessed by:

t = p->dc[0].z;
t = p->dc[0].h;

is weird... to me anyways. Its because we casted the lb pointer as a pc type
and its somehow still able to go and get the correct values of 201 and 202
via the following pointer member:

struct tag_pc_table *dc;

when the correct pointer to access those values should of been:

struct tag_lb_table *dc;

which resides in the lb type struct ???? In the previous thread, we did
agree, that this was not possible and wouldn't work... no?

So the example code above simply casts in f1() like this:

pc *p = x;

and miraculously (so to speak !) I all of the sudden have access to members
in the tag_pc_table or tag_lb_table tables via the dc pointer in the
struct tag_pc structure even though whatever I passed in got casted to pc
type?

I like it, because it works and it does what I need, I don't like it because
I don't know why it works!

All feedback appreciated!

--
Best regards
Roberto