Re: No casting of void* ???
Hello Igor,
This can't possibly compile - t is not a pointer. Post your actual code.
Careless me!, Here you go, this compiles:
===================================
#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;
}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,o;
t = p->dc[0].z;
o = p->dc[0].h;
p->dc[0].z = 998;
p->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 binary layout of the structures is compatible enough for this to
work out. Remember, the compiled code doesn't deal with names, but with
addresses and offsets and such.
I think I understand what's going on here! I am getting fooled by thinking
that I am referencing the lb_table members when in reality I am always using
the pc_table ones since they are the same (atleast for the members I am
referencing) .
But now, given this issue, like many have told me to use a base structure,
this changes things.... I will post again, standby!
--
Best regards
Roberto
"Igor Tandetnik" wrote:
Robby <Robby@discussions.microsoft.com> wrote:
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:
Try a) making sure the two table structures are different size, as they
are in your real code, and b) accessing table elements at indexes other
than zero. Then you'll notice that your assignments go to all the wrong
places.
=================================
#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;
This can't possibly compile - t is not a pointer. Post your actual code.
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.
The binary layout of the structures is compatible enough for this to
work out. Remember, the compiled code doesn't deal with names, but with
addresses and offsets and such.
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?
That would depend on what the definition of "we" is. I personally didn't
agree with any such thing. My example in that thread relies heavily on
the ability to access members of layout-compatible structures via
pointers of a wrong type (witness the ThreeLinks structure).
--
With best wishes,
Igor Tandetnik
With sufficient thrust, pigs fly just fine. However, this is not
necessarily a good idea. It is hard to be sure where they are going to
land, and it could be dangerous sitting under them as they fly
overhead. -- RFC 1925