storing related structs

[Gray Alien]

I have two related structs:
struct A
{
int x ;
void * data ;
};

and

struct B
{
int x, y ;
double z ;
void * data1, *data2 ;
};
These structures (not pointers to them), need to be stored in a another
struct:

struct C
{
unsigned id ;
char name ;

DATA_TYPE the_struct ;
};
Where DATA_TYPE is EITHER a struct A or struct B.

For compatability with existing libraries, I cannot use a void * (for
instance), and cast between struct A and B.
Is there a soln to this problem ?

[Army1987]

"Gray Alien" <gr**@andromeda.comha scritto nel messaggio news:Z7******************************@bt.com...

>I have two related structs:
struct A
{
int x ;
void * data ;
};

and

struct B
{
int x, y ;
double z ;
void * data1, *data2 ;
};
These structures (not pointers to them), need to be stored in a another struct:

struct C
{
unsigned id ;
char name ;

DATA_TYPE the_struct ;
};
Where DATA_TYPE is EITHER a struct A or struct B.

For compatability with existing libraries, I cannot use a void * (for instance), and cast between struct A and B.
Is there a soln to this problem ?

struct C {
unsigned id;
char name; /* do you mean *name, or name[LARGE_ENOUGH]? */
enum { strA, strB } type;
union {
struct A str_A;
struct B str_B;
} the_struct;
};

A union is like a struct, but can only hold an element at a time.
You access members of unions like members of struct. For example,
in the case above to access the double of a struct B in a struct C,
you'll have to use mystructC.the_struct.str_B.z
Or try to find a better way to do what you're trying to do.

[gw7rib]

On 30 Jun, 13:15, "Army1987" <[e-mail]:

"Gray Alien" <[e-mail] scritto nel messaggionews:Z7******************************@bt. com...

I have two related structs:

struct A
{
int x ;
void * data ;
};

and

struct B
{
int x, y ;
double z ;
void * data1, *data2 ;
};

These structures (not pointers to them), need to be stored in a another struct:

struct C
{
unsigned id ;
char name ;

DATA_TYPE the_struct ;
};

Where DATA_TYPE is EITHER a struct A or struct B.

For compatability with existing libraries, I cannot use a void * (for instance), and cast between struct A and B.

Is there a soln to this problem ?

struct C {
unsigned id;
char name; /* do you mean *name, or name[LARGE_ENOUGH]? */
enum { strA, strB } type;
union {
struct A str_A;
struct B str_B;
} the_struct;

};

A union is like a struct, but can only hold an element at a time.
You access members of unions like members of struct. For example,
in the case above to access the double of a struct B in a struct C,
you'll have to use mystructC.the_struct.str_B.z
Or try to find a better way to do what you're trying to do.

To the OP: One way of doing it would be to use a union, as Army1987
has suggested. However, if space isn't an issue, you might do better
including both a struct A and a struct B, and just using the one that
you want. This would seem to have less chance of going horribly wrong,
and might make your code clearer. Is there some reason why this would
not work?

Hope that helps.
Paul.

[Flash Gordon]

Gray Alien wrote, On 30/06/07 12:28:

I have two related structs:

struct A

<snip>

struct B

<snip>

These structures (not pointers to them), need to be stored in a another
struct:

struct C
{
unsigned id ;
char name ;
DATA_TYPE the_struct ;
};
Where DATA_TYPE is EITHER a struct A or struct B.

For compatability with existing libraries, I cannot use a void * (for
instance), and cast between struct A and B.

Is there a soln to this problem ?

Yes, use a union of the two struct types. Obviously you need something
to indicate what is stored so you know how to access it.
--
Flash Gordon

[Grey Alien]

Army1987 wrote:

"Grey Alien" <gr**@andromeda.comha scritto nel messaggio news:Z7******************************@bt.com...

<snip>
</snip>

>>Is there a soln to this problem ?

struct C {
unsigned id;
char name; /* do you mean *name, or name[LARGE_ENOUGH]? */
enum { strA, strB } type;
union {
struct A str_A;
struct B str_B;
} the_struct;
};

A union is like a struct, but can only hold an element at a time.
You access members of unions like members of struct. For example,
in the case above to access the double of a struct B in a struct C,
you'll have to use mystructC.the_struct.str_B.z
Or try to find a better way to do what you're trying to do.

Thanks - I forgot about unions ! (don't use them that much). Yes this
soln will suffice for what I want to do.

[Grey Alien]

Army1987 wrote:

<snip></snip>

struct C {
unsigned id;
char name; /* do you mean *name, or name[LARGE_ENOUGH]? */
enum { strA, strB } type;

Why have you declared an enum here? ^ (can't see why this is needed)

union {
struct A str_A;
struct B str_B;
} the_struct;
};

[Army1987]

"Grey Alien" <gr**@andromeda.comha scritto nel messaggio news:if******************************@bt.com...

>

Army1987 wrote:

<snip></snip>

>struct C {
unsigned id;
char name; /* do you mean *name, or name[LARGE_ENOUGH]? */
enum { strA, strB } type;

Why have you declared an enum here? ^ (can't see why this is needed)

The point is, you have to somehow keep track of wheter the union
contains a struct A or a struct B.

> union {
struct A str_A;
struct B str_B;
} the_struct;
};

[Chris Dollin]

Grey Alien wrote:

Army1987 wrote:

<snip></snip>

>struct C {
unsigned id;
char name; /* do you mean *name, or name[LARGE_ENOUGH]? */
enum { strA, strB } type;

Why have you declared an enum here? ^ (can't see why this is needed)

So you can record whether this union ...

> union {
struct A str_A;
struct B str_B;
} the_struct;

.... is currently supposed to be an A or a B.

>};

As far as solutions go, I think we don't know what problem
you're trying to solve, only the C context you're trying
to solve it in. It may make a difference.

--
Pressure Hedgehog
The "good old days" used to be much better.

[CBFalconer]

Gray Alien wrote:

>

.... snip ...

>
These structures (not pointers to them), need to be stored in a
another struct:

struct C
{
unsigned id ;
char name ;

DATA_TYPE the_struct ;
};

Look up the use of 'union'.

--
<http://www.cs.auckland.ac.nz/~pgut001/pubs/vista_cost.txt>
<http://www.securityfocus.com/columnists/423>
<http://www.aaxnet.com/editor/edit043.html>
cbfalconer at maineline dot net

--
Posted via a free Usenet account from http://www.teranews.com

[Flash Gordon]

gw****@aol.com wrote, On 30/06/07 13:25:

On 30 Jun, 13:15, "Army1987" <[e-mail]:

>"Gray Alien" <[e-mail] scritto nel messaggionews:Z7******************************@bt. com...

<snip>

>>Where DATA_TYPE is EITHER a struct A or struct B.
For compatability with existing libraries, I cannot use a void * (for instance), and cast between struct A and B.
Is there a soln to this problem ?

struct C {
unsigned id;
char name; /* do you mean *name, or name[LARGE_ENOUGH]? */
enum { strA, strB } type;
union {
struct A str_A;
struct B str_B;
} the_struct;

};

A union is like a struct, but can only hold an element at a time.
You access members of unions like members of struct. For example,
in the case above to access the double of a struct B in a struct C,
you'll have to use mystructC.the_struct.str_B.z
Or try to find a better way to do what you're trying to do.

To the OP: One way of doing it would be to use a union, as Army1987
has suggested. However, if space isn't an issue, you might do better
including both a struct A and a struct B, and just using the one that
you want. This would seem to have less chance of going horribly wrong,
and might make your code clearer. Is there some reason why this would
not work?

Hope that helps.

If it is only valid to have one or the other then a union expresses the
intent better and if you are accessing the wrong member something has
already gone horribly wrong.
--
Flash Gordon

[Grey Alien]

Army1987 wrote:

"Grey Alien" <gr**@andromeda.comha scritto nel messaggio news:if******************************@bt.com...

>>
Army1987 wrote:

<snip></snip>

>>>struct C {
unsigned id;
char name; /* do you mean *name, or name[LARGE_ENOUGH]? */
enum { strA, strB } type;

Why have you declared an enum here? ^ (can't see why this is needed)

The point is, you have to somehow keep track of wheter the union
contains a struct A or a struct B.

Ah, I see. I understand now. Actually it won't be necessary since the
structs themselves contain a 'type' enum

>

>> union {
struct A str_A;
struct B str_B;
} the_struct;
};

[Chris Dollin]

Grey Alien wrote:

Army1987 wrote:

>"Grey Alien" <gr**@andromeda.comha scritto nel messaggio
news:if******************************@bt.com...

>>>
Army1987 wrote:

<snip></snip>

struct C {
unsigned id;
char name; /* do you mean *name, or name[LARGE_ENOUGH]? */
enum { strA, strB } type;

Why have you declared an enum here? ^ (can't see why this is needed)

The point is, you have to somehow keep track of wheter the union
contains a struct A or a struct B.

Ah, I see. I understand now. Actually it won't be necessary since the
structs themselves contain a 'type' enum

Well, you have to be /careful/, then: you can only reliably get
at that enum (IIRC) if it's either the first field in the structure
(A or B) or a member of that first field.

Safer, I would have said, to have it outside the union -- but
it depends on the /full details of the problem you're trying
to solve/, with which we have not been blessed.

--
Unshriven Hedgehog
"Our future looks secure, but it's all out of our hands"
- Magenta, /Man and Machine/

[Grey Alien]

Chris Dollin wrote:

<snip></snip>

>
Well, you have to be /careful/, then: you can only reliably get
at that enum (IIRC) if it's either the first field in the structure
(A or B) or a member of that first field.

Safer, I would have said, to have it outside the union -- but
it depends on the /full details of the problem you're trying
to solve/, with which we have not been blessed.

I agree. Actually, I decided to err on the side of caution and use the
type enum field in struct C (external to the related structs).

[Martin Ambuhl]

Gray Alien wrote:

I have two related structs:
struct A
{
int x ;
void * data ;
};

and

struct B
{
int x, y ;
double z ;
void * data1, *data2 ;
};
These structures (not pointers to them), need to be stored in a another
struct:

struct C
{
unsigned id ;
char name ;

DATA_TYPE the_struct ;
};
Where DATA_TYPE is EITHER a struct A or struct B.

typedef union {
struct A;
struct B;
} DATA_TYPE;

[David Thompson]

...
On Sat, 30 Jun 2007 15:05:51 GMT, Chris Dollin
<[e-mail]:

Grey Alien wrote:

Army1987 wrote:

<snip>

The point is, you have to somehow keep track of wheter the union
contains a struct A or a struct B.

Ah, I see. I understand now. Actually it won't be necessary since the
structs themselves contain a 'type' enum

Well, you have to be /careful/, then: you can only reliably get
at that enum (IIRC) if it's either the first field in the structure
(A or B) or a member of that first field.

Actually it's safe if it is in (or within) a common initial sequence
of fields with compatible types. But in practice first is the easiest
way to satisfy this, and almost always desirable anyway.

- formerly david.thompson1 || achar(64) || worldnet.att.net