access struct member fields dynamically

[sean.scanlon]

can someone help understand how i can could access a struct field
dymanically like: foo->fields[i] ?

when i try to compile this i get the following error: 'struct pwd' has
no member named 'fields'

is there a way to treat fields[i] as the member name of the struct?

example code:

struct pwd {
char *first;
char *last;
char *bar;
};

struct pwd *foo;

char* fields[] = {"first", "last", "bar"};

int main (int argc, char* argv[ ]) {

int i;

const int f_size = ( sizeof fields ) / ( sizeof fields[0] );

for (i = 0; i<f_size;i++) {

printf("%d == %s (%s)\n", i, fields[i], foo->fields[i]);

}

return 0;
}
Thanks for any help,
-sean

[Morris Dovey]

se**********@gm ail.com (in
11************* ********@b28g20 00...legro ups.com) said:

| can someone help understand how i can could access a struct field
| dymanically like: foo->fields[i] ?
|
| when i try to compile this i get the following error: 'struct pwd'
| has no member named 'fields'
|
| is there a way to treat fields[i] as the member name of the struct?
|
|
|
| example code:
|
| struct pwd {
| char *first;
| char *last;
| char *bar;
| };
|
| struct pwd *foo;
|
| char* fields[] = {"first", "last", "bar"};
|
| int main (int argc, char* argv[ ]) {
|
| int i;
|
| const int f_size = ( sizeof fields ) / ( sizeof fields[0] );
|
| for (i = 0; i<f_size;i++) {
|
| printf("%d == %s (%s)\n", i, fields[i], foo->fields[i]);
|
| }
|
| return 0;
| }

How about something like:

#define first fields[0]
#define last fields[1]
#define bar fields[2]

struct pwd
{ char *fields[3];
} = { NULL,NULL,NULL };

struct pwd *foo;
char *names[] = {"first", "last", "bar"};

int main (void)
{ int i;
const int f_size = ( sizeof names ) / ( sizeof names[0] );

for (i = 0; i<f_size; i++)
{ printf("%d == %s (%s)\n", i, names[i], foo->fields[i]);
}
return 0;
}

--
Morris Dovey
DeSoto Solar
DeSoto, Iowa USA
http://www.iedu.com/DeSoto

[Giorgio Silvestri]

"Morris Dovey" <mr*****@iedu.c omha scritto nel messaggio
news:44******** *************** @news.qwest.net ...

se**********@gm ail.com (in
11************* ********@b28g20 00...legro ups.com) said:

| can someone help understand how i can could access a struct field
| dymanically like: foo->fields[i] ?
|
| when i try to compile this i get the following error: 'struct pwd'
| has no member named 'fields'
|
| is there a way to treat fields[i] as the member name of the struct?
|
|
|
| example code:
|
| struct pwd {
| char *first;
| char *last;
| char *bar;
| };
|
| struct pwd *foo;
|
| char* fields[] = {"first", "last", "bar"};
|
| int main (int argc, char* argv[ ]) {
|
| int i;
|
| const int f_size = ( sizeof fields ) / ( sizeof fields[0] );
|
| for (i = 0; i<f_size;i++) {
|
| printf("%d == %s (%s)\n", i, fields[i], foo->fields[i]);
|
| }
|
| return 0;
| }

How about something like:

#define first fields[0]
#define last fields[1]
#define bar fields[2]

Unused.

>
struct pwd
{ char *fields[3];
} = { NULL,NULL,NULL };

Missing variable:

struct pwd {
char *fields[3];
} var = { {NULL,NULL,NULL } };

>
struct pwd *foo;
char *names[] = {"first", "last", "bar"};

int main (void)
{ int i;
const int f_size = ( sizeof names ) / ( sizeof names[0] );

for (i = 0; i<f_size; i++)
{ printf("%d == %s (%s)\n", i, names[i], foo->fields[i]);
}
return 0;
}

Segfault!
foo->fields[i] is NULL.
--
Giorgio Silvestri
DSP/Embedded/Real Time OS Software Engineer

[Morris Dovey]

Giorgio Silvestri (in F5************* *******@twister 2.libero.it) said:

| "Morris Dovey" <mr*****@iedu.c omha scritto nel messaggio
| news:44******** *************** @news.qwest.net ...
|| se**********@gm ail.com (in
|| 11************* ********@b28g20 00...legro ups.com) said:
||
|| How about something like:
||
|| #define first fields[0]
|| #define last fields[1]
|| #define bar fields[2]
|
| Unused.

But useful for getting the idea across.

|| struct pwd
|| { char *fields[3];
|| } = { NULL,NULL,NULL };
|
| Missing variable:

Good catch!

| struct pwd {
| char *fields[3];
| } var = { {NULL,NULL,NULL } };
|
|| struct pwd *foo;
|| char *names[] = {"first", "last", "bar"};
||
|| int main (void)
|| { int i;
|| const int f_size = ( sizeof names ) / ( sizeof names[0] );
||
|| for (i = 0; i<f_size; i++)
|| { printf("%d == %s (%s)\n", i, names[i], foo->fields[i]);
|| }
|| return 0;
|| }
||
|
| Segfault!
| foo->fields[i] is NULL.

Exactly so; but I would guess that the OP intends to actually use
those pointers for something. If not, then a test

printf("%d == %s (%s)\n", i, names[i], foo->fields[i] ?
foo->fields[i] : "(null)");

would certainly be in order.

--
Morris Dovey
DeSoto Solar
DeSoto, Iowa USA
http://www.iedu.com/DeSoto

[Fred Kleinschmidt]

"Giorgio Silvestri" <gi************ **@libero.itwro te in message
news:F5******** ************@tw ister2.libero.i t...

>
"Morris Dovey" <mr*****@iedu.c omha scritto nel messaggio
news:44******** *************** @news.qwest.net ...

>se**********@gm ail.com (in
11************* ********@b28g20 00...legro ups.com) said:

| can someone help understand how i can could access a struct field
| dymanically like: foo->fields[i] ?
|
| when i try to compile this i get the following error: 'struct pwd'
| has no member named 'fields'
|
| is there a way to treat fields[i] as the member name of the struct?
|
|
|
| example code:
|
| struct pwd {
| char *first;
| char *last;
| char *bar;
| };
|
| struct pwd *foo;
|
| char* fields[] = {"first", "last", "bar"};
|
| int main (int argc, char* argv[ ]) {
|
| int i;
|
| const int f_size = ( sizeof fields ) / ( sizeof fields[0] );
|
| for (i = 0; i<f_size;i++) {
|
| printf("%d == %s (%s)\n", i, fields[i], foo->fields[i]);
|
| }
|
| return 0;
| }

How about something like:

#define first fields[0]
#define last fields[1]
#define bar fields[2]

Unused.

>>
struct pwd
{ char *fields[3];
} = { NULL,NULL,NULL };

Missing variable:

struct pwd {
char *fields[3];
} var = { {NULL,NULL,NULL } };

>>
struct pwd *foo;
char *names[] = {"first", "last", "bar"};

int main (void)
{ int i;
const int f_size = ( sizeof names ) / ( sizeof names[0] );

for (i = 0; i<f_size; i++)
{ printf("%d == %s (%s)\n", i, names[i], foo->fields[i]);
}
return 0;
}

Segfault!
foo->fields[i] is NULL.

No. foo itself has not been pointed to anything.
Therefore dereferencing foo leads to bad things.

>

--
Giorgio Silvestri
DSP/Embedded/Real Time OS Software Engineer

--
Fred L. Kleinschmidt
Boeing Associate Technical Fellow
Technical Architect, Software Reuse Project

[Keith Thompson]

se**********@gm ail.com writes:

can someone help understand how i can could access a struct field
dymanically like: foo->fields[i] ?

when i try to compile this i get the following error: 'struct pwd' has
no member named 'fields'

is there a way to treat fields[i] as the member name of the struct?

example code:

struct pwd {
char *first;
char *last;
char *bar;
};

struct pwd *foo;

char* fields[] = {"first", "last", "bar"};

Identifiers in your source code do not exist during execution.
There's no direct way to map from the string "first" to the identifier
first. (It's not inconceivable that your implementation might provide
some way of doing to, most likely for use by source-level debuggers,
but if so I strongly advise against trying to use it.)

int main (int argc, char* argv[ ]) {

int i;

const int f_size = ( sizeof fields ) / ( sizeof fields[0] );

for (i = 0; i<f_size;i++) {

printf("%d == %s (%s)\n", i, fields[i], foo->fields[i]);

}

return 0;
}

There's a very simple and straightforward way to refer to the members
as array elements: Declare them that way.

struct pwd {
char *fields[3];
};

If you want to be able to refer to them either as array elements or as
named fields, the first thing you should do is stop and consider
whether you really want to do that. In most cases, it only makes
sense to do one or the other. (And, of course, the members of a
structure needn't all be of the same type.)

You might be tempted to use a union to overlay your array with a
sub-struct containing the individual members. Resist this temptation.
There's no guarantee that the layout will match. Worse, it *probably*
will match, meaning that your code will have a potential bug that you
probably won't be able to detect in testing.

As someone else suggested, you can use macros to make the array
elements look like individual struct members -- but since macros just
do textual substitution, you may eventually run into a situation where
things mysteriously don't work.

Or you can declare an enumerated type and use the enumerators as
indices:

enum index_type { FIRST, LAST, BAR, ARRAY_LENGTH=BA R+1 };

struct pwd {
char *fields[ARRAY_LENGTH];
};

struct pwd obj;

... obj.fields[BAR] ...

(I haven't tested this.)

Whenever possible, work with the language rather than trying to warp
it to your purposes (though sometimes that's the only solution).

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <* <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Thomas Matthews]

se**********@gm ail.com wrote:

can someone help understand how i can could access a struct field
dymanically like: foo->fields[i] ?

when i try to compile this i get the following error: 'struct pwd' has
no member named 'fields'

is there a way to treat fields[i] as the member name of the struct?

example code:

struct pwd {
char *first;
char *last;
char *bar;
};

struct pwd *foo;

char* fields[] = {"first", "last", "bar"};

int main (int argc, char* argv[ ]) {

int i;

const int f_size = ( sizeof fields ) / ( sizeof fields[0] );

for (i = 0; i<f_size;i++) {

printf("%d == %s (%s)\n", i, fields[i], foo->fields[i]);

}

return 0;
}
Thanks for any help,
-sean

Here is some untested code demonstrating the concept of storing
the name of a field along with its offset:

struct pwd {
char *first;
char *last;
char *bar;
};

struct Name_Offset
{
const char * field_name;
size_t field_offset;
};

const struct Name_Offset offset_table[] =
{
{"first", offsetof(struct pwd.first)},
{"last", offsetof(struct pwd.last)},
{"bar", offsetof(struct pwd.bar)}
};
const size_t Field_Quantity =
sizeof(offset_t able) / sizeof(offset_t able[0]);

The big issue with accessing fields by name is that you have
to convert the name into an offset into the structure, then
access the field.
--
Thomas Matthews

C++ newsgroup welcome message:
http://www.slack.net/~shiva/welcome.txt
C++ Faq: http://www.parashift.com/c++-faq-lite
C Faq: http://www.eskimo.com/~scs/c-faq/top.html
alt.comp.lang.l earn.c-c++ faq:
http://www.comeaucomputing.com/learn/faq/
Other sites:
http://www.josuttis.com -- C++ STL Library book
http://www.sgi.com/tech/stl -- Standard Template Library

[swets]

You can try this way too -
struct pwd {
union {
struct {
char *first;
char *last;
char *bar;
}s;
char *fields[3];
}u;
};
};
and then you can access fields like foo->u.fields[i].

Any comments?

Sweta

se**********@gm ail.com wrote:

can someone help understand how i can could access a struct field
dymanically like: foo->fields[i] ?

when i try to compile this i get the following error: 'struct pwd' has
no member named 'fields'

is there a way to treat fields[i] as the member name of the struct?

example code:

struct pwd {
char *first;
char *last;
char *bar;
};

struct pwd *foo;

char* fields[] = {"first", "last", "bar"};

int main (int argc, char* argv[ ]) {

int i;

const int f_size = ( sizeof fields ) / ( sizeof fields[0] );

for (i = 0; i<f_size;i++) {

printf("%d == %s (%s)\n", i, fields[i], foo->fields[i]);

}

return 0;
}
Thanks for any help,
-sean

[Giorgio Silvestri]

"Keith Thompson" <ks***@mib.orgh a scritto nel messaggio
news:ln******** ****@nuthaus.mi b.org...

se**********@gm ail.com writes:

[...]

There's a very simple and straightforward way to refer to the members
as array elements: Declare them that way.

struct pwd {
char *fields[3];
};

If you want to be able to refer to them either as array elements or as
named fields, the first thing you should do is stop and consider
whether you really want to do that. In most cases, it only makes
sense to do one or the other. (And, of course, the members of a
structure needn't all be of the same type.)

You might be tempted to use a union to overlay your array with a
sub-struct containing the individual members. Resist this temptation.
There's no guarantee that the layout will match. Worse, it *probably*
will match, meaning that your code will have a potential bug that you
probably won't be able to detect in testing.

As someone else suggested, you can use macros to make the array
elements look like individual struct members -- but since macros just
do textual substitution, you may eventually run into a situation where
things mysteriously don't work.

Or you can declare an enumerated type and use the enumerators as
indices:

enum index_type { FIRST, LAST, BAR, ARRAY_LENGTH=BA R+1 };

struct pwd {
char *fields[ARRAY_LENGTH];
};

struct pwd obj;

... obj.fields[BAR] ...

this version is simpler and probably more parametric:

enum index_type { FIRST, LAST, BAR, ARRAY_LENGTH };

I can also change, the order:

enum index_type { FIRST, BAR, LAST , ARRAY_LENGTH };

ARRAY_LENGTH is always the last of course!


--
Giorgio Silvestri
DSP/Embedded/Real Time OS Software Engineer

[Giorgio Silvestri]

"Fred Kleinschmidt" <fr************ ******@boeing.c omha scritto nel
messaggio news:J3******** @news.boeing.co m...

>
"Giorgio Silvestri" <gi************ **@libero.itwro te in message
news:F5******** ************@tw ister2.libero.i t...

"Morris Dovey" <mr*****@iedu.c omha scritto nel messaggio
news:44******** *************** @news.qwest.net ...

se**********@gm ail.com (in
11************* ********@b28g20 00...legro ups.com) said:

| can someone help understand how i can could access a struct field
| dymanically like: foo->fields[i] ?
|
| when i try to compile this i get the following error: 'struct pwd'
| has no member named 'fields'
|
| is there a way to treat fields[i] as the member name of the struct?
|
|
|
| example code:
|
| struct pwd {
| char *first;
| char *last;
| char *bar;
| };
|
| struct pwd *foo;
|
| char* fields[] = {"first", "last", "bar"};
|
| int main (int argc, char* argv[ ]) {
|
| int i;
|
| const int f_size = ( sizeof fields ) / ( sizeof fields[0] );
|
| for (i = 0; i<f_size;i++) {
|
| printf("%d == %s (%s)\n", i, fields[i], foo->fields[i]);
|
| }
|
| return 0;
| }

How about something like:

#define first fields[0]
#define last fields[1]
#define bar fields[2]

Unused.

>
struct pwd
{ char *fields[3];
} = { NULL,NULL,NULL };

Missing variable:

struct pwd {
char *fields[3];
} var = { {NULL,NULL,NULL } };

>
struct pwd *foo;
char *names[] = {"first", "last", "bar"};

int main (void)
{ int i;
const int f_size = ( sizeof names ) / ( sizeof names[0] );

for (i = 0; i<f_size; i++)
{ printf("%d == %s (%s)\n", i, names[i], foo->fields[i]);
}
return 0;
}

Segfault!
foo->fields[i] is NULL.

No. foo itself has not been pointed to anything.
Therefore dereferencing foo leads to bad things.

Thank you. Of course I suppose:

/* ... */
foo = &var;
/* ... */


--
Giorgio Silvestri
DSP/Embedded/Real Time OS Software Engineer