getting variable type in C

[Michael McGarry]

Hi,

I am pretty sure this is not possible, but maybe somehow it is.

Given a variable, can I tell what type it is at runtime?

Michael

[Trent Buck]

Quoth Michael McGarry on or about 2004-11-14:

Some compilers, like gcc, provide a construct named
typeof() which produces the object type.

Is there really a typeof()?? Which standard library is it in?

Typeof *IS NOT STANDARD*. Now we're clear on that, if you have the GCC,
typing
info gcc 'C Extensions' Typeof

will provide you with documentation (for the GCC version).

-trent

[Lawrence Kirby]

On Sun, 14 Nov 2004 13:32:08 +0000, Rouben Rostamian wrote:

In article <T9Bld.58779$EZ .51910@okepread 07>,
Michael McGarry <mm******@nospa m.org> wrote:

Hi,

I am pretty sure this is not possible, but maybe somehow it is.

Given a variable, can I tell what type it is at runtime?

How would you want this information to be represented? How would you use
it? Remember that C is statically typed. You know at the point you use
a variable what type it is, you just have to look at the definition for
the variable.
Some compilers, like gcc, provide a construct named
typeof() which produces the object type.
AFAIK this is just a band-aid for macros, replicating a type in
another declaration or a cast - strictly a compile time thing. It doesn't
address the OP's question of a runtime test. Since C doesn't support
Runtime Type Information, inheritance or any sort of dynamic typing a
runtime test doesn't make much sense - it just tells you what you already
know.
Unfortunately,
(and inexplicably) typeof() has not found its way into
the C standard.

There may be the odd occasion where it is useful but don't see that these
are common enough to make it a language requirement.

Lawrence

[Rouben Rostamian]

In article <pa************ ***********@net active.co.uk>,
Lawrence Kirby <lk****@netacti ve.co.uk> wrote:

On Sun, 14 Nov 2004 13:32:08 +0000, Rouben Rostamian wrote:

In article <T9Bld.58779$EZ .51910@okepread 07>,
Michael McGarry <mm******@nospa m.org> wrote:

Hi,

I am pretty sure this is not possible, but maybe somehow it is.

Given a variable, can I tell what type it is at runtime?

How would you want this information to be represented? How would you use
it? Remember that C is statically typed. You know at the point you use
a variable what type it is, you just have to look at the definition for
the variable.

Some compilers, like gcc, provide a construct named
typeof() which produces the object type.

AFAIK this is just a band-aid for macros, replicating a type in
another declaration or a cast - strictly a compile time thing. It doesn't
address the OP's question of a runtime test. Since C doesn't support
Runtime Type Information, inheritance or any sort of dynamic typing a
runtime test doesn't make much sense - it just tells you what you already
know.

Unfortunately,
(and inexplicably) typeof() has not found its way into
the C standard.

There may be the odd occasion where it is useful but don't see that these
are common enough to make it a language requirement.

Of course you are right in saying that a runtime operator for
getting an object's type doesn't make much sense in C.

I am not sure, however, if I would characterize gcc's typeof()
as a "band-aid for macros". Calling it band-aid implies that
there may be a better solution in sight. Look at:

#define swap(a,b) do \
{ typeof(a) swap_tmp = a; a = b; b = swap_tmp; } while(0)

The alternative is to write a different swap macro/function for
each different type. Which is the cleaner? Which is the band-aid?

A more interesting and useful application of a typeof()
construct would be in the dynamic allocation of two-dimensional
arrays. Instead of having to supply multiple functions such as:

double **make_matrix_d ouble (size_t m, size_t n);
int **make_matrix_i nt (size_t m, size_t n);
complex **make_matrix_c omplex (size_t m, size_t n);
mystruct **make_matrix_m ystruct(size_t m, size_t n);

you may write a single make_matrix() macro for all types.
Very handy for numerical analysts working with matrix algebra.
I wouldn't dismiss this an "odd occasion where it is useful".

--
Rouben Rostamian

[Lawrence Kirby]

On Mon, 15 Nov 2004 15:36:05 +0000, Rouben Rostamian wrote:

....

I am not sure, however, if I would characterize gcc's typeof()
as a "band-aid for macros". Calling it band-aid implies that
there may be a better solution in sight. Look at:
It is something to squeeze a bit more functionality out of
macros. I don't see the implication of something better in sight.
#define swap(a,b) do \
{ typeof(a) swap_tmp = a; a = b; b = swap_tmp; } while(0)
I've never seen much use for swap macros myself. When application
code does enough swapping to warrant one it is usually over a
small number of types.
The alternative is to write a different swap macro/function for
each different type. Which is the cleaner? Which is the band-aid?
Maybe both are band-aids.
A more interesting and useful application of a typeof()
construct would be in the dynamic allocation of two-dimensional
arrays. Instead of having to supply multiple functions such as:

double **make_matrix_d ouble (size_t m, size_t n);
int **make_matrix_i nt (size_t m, size_t n);
complex **make_matrix_c omplex (size_t m, size_t n);
mystruct **make_matrix_m ystruct(size_t m, size_t n);

you may write a single make_matrix() macro for all types.
Very handy for numerical analysts working with matrix algebra.
I wouldn't dismiss this an "odd occasion where it is useful".

I'd say that's precisely what it is. :-)

I didn't claim that band-aids aren't useful. But are examples like this
enough to warrant an extra feature in the language?

IIRC typeof seemed like a good idea to me in 1999, but I don't
see its failure to get into C99 as a great problem.

Lawrence

[Keith Thompson]

ga*****@yin.int eraccess.com (Kenny McCormack) writes:
[...]

Stick around for a bit, and you will come to understand more things about
this very religious newsgroup.

One of the fundamental tenents of this religion is that if it is not
standard, it is *not C* (1). That is, the claim is not that it is merely
"not standard C", but that it is not C at all. Bog knows what it is (for
all they care, it might be Fortran or Frobozz or your left ear), but
neither of the following are in any sense written or in any way related to
the C language:

socket(a,b,c);
or messagebox(lpWh atever,OtherWei rdWindowsParame terType,etc,etc );

I don't think most of us would claim that non-standard C is "not C".
After all, the language itself allows for extensions, and library
functions like socket() and messagebox() could well be written in the
language itself.

But that's not the point. The point is that non-standard C is not
what we discuss in this newsgroup. There are newsgroups for Unix,
Windows, gcc, etc. where these things are topical, and you can find
people who actually know about them. There's nothing wrong with using
non-standard features when they're appropriate, we just can't help you
with them here. As you can see from the level of traffic, standard C
leaves us plenty to discuss.

--
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.

[J. J. Farrell]

Robert Gamble <rg*******@gmai l.com> wrote in message news:<pa******* *************** ******@gmail.co m>...

On Sun, 14 Nov 2004 21:49:14 -0500, Joe Wright wrote:

Michael McGarry wrote:

Rouben Rostamian wrote:

In article <T9Bld.58779$EZ .51910@okepread 07>,
Michael McGarry <mm******@nospa m.org> wrote:

> Hi,
>
> I am pretty sure this is not possible, but maybe somehow it is.
>
> Given a variable, can I tell what type it is at runtime?

Some compilers, like gcc, provide a construct named
typeof() which produces the object type. Unfortunately,
(and inexplicably) typeof() has not found its way into
the C standard.

Is there really a typeof()?? Which standard library is it in?

Michael

No typeof in C.

I don't understand the confusion/sarcasm here. Rouben clearly stated it
was not standard. It is however a useful feature available to many
developers and there is no harm voicing the fact that it exists (along
with the fact that it is not standard as Rouben did) when there is no
standard solution and the information may help the OP.

What sarcasm? Rouben said it wasn't standard. Michael appeared to miss
that since he asked what standard header it aapeared in. Joe restated
that it's not part of C as such. What's your problem?

[J. J. Farrell]

ga*****@yin.int eraccess.com (Kenny McCormack) wrote in message news:<cn******* ***@yin.interac cess.com>...

In article <pa************ *************** *@gmail.com>,
Robert Gamble <rg*******@gmai l.com> wrote:
...

I don't understand the confusion/sarcasm here. Rouben clearly stated it
was not standard. It is however a useful feature available to many
developers and there is no harm voicing the fact that it exists (along
with the fact that it is not standard as Rouben did) when there is no
standard solution and the information may help the OP.
Stick around for a bit, and you will come to understand more things about
this very religious newsgroup.

One of the fundamental tenents of this religion is that if it is not
standard, it is *not C* (1). That is, the claim is not that it is merely
"not standard C", but that it is not C at all.

If you disagree with this, define C.
Bog knows what it is (for
all they care, it might be Fortran or Frobozz or your left ear),
It's an extended form of C, or a similar language based on C.
but neither of the following are in any sense written or in any way
related to the C language:

socket(a,b,c);
or messagebox(lpWh atever,OtherWei rdWindowsParame terType,etc,etc );

Don't talk nonsense. If the poster provides declarations for the
functions and definitions of any non-standard types used, then
there is plenty to discuss about such things. For example,
discussion of whether or not the parameters being passed have
the appropriate types would be fine. What is obviously nothing
to do with C is discussion of why the call didn't make a message
box appear in the expected place, for example.

[S.Tobias]

Rouben Rostamian <ro****@pc18.ma th.umbc.edu> wrote:

#define swap(a,b) do \
{ typeof(a) swap_tmp = a; a = b; b = swap_tmp; } while(0) The alternative is to write a different swap macro/function for
each different type.

For this and similar kind of macros I pass the type in argument:

#define SWAP(type, a, b) do \
{ type swap_tmp = a; a = b; b = swap_tmp; } while(0)

SWAP(struct mystruct, a, b);

(And I miss typeof() sometimes, too.)

--
Stan Tobias
sed 's/[A-Z]//g' to email

[Robert Gamble]

On Mon, 15 Nov 2004 15:02:56 -0800, J. J. Farrell wrote:

Robert Gamble <rg*******@gmai l.com> wrote in message
news:<pa******* *************** ******@gmail.co m>...

On Sun, 14 Nov 2004 21:49:14 -0500, Joe Wright wrote:

> Michael McGarry wrote:
>> Rouben Rostamian wrote:
>>
>>> In article <T9Bld.58779$EZ .51910@okepread 07>, Michael McGarry
>>> <mm******@nospa m.org> wrote:
>>>
>>>> Hi,
>>>>
>>>> I am pretty sure this is not possible, but maybe somehow it is.
>>>>
>>>> Given a variable, can I tell what type it is at runtime?
>>>
>>>
>>>
>>> Some compilers, like gcc, provide a construct named typeof() which
>>> produces the object type. Unfortunately, (and inexplicably)
>>> typeof() has not found its way into the C standard.
>>>
>> Is there really a typeof()?? Which standard library is it in?
>>
>> Michael
>
> No typeof in C.

I don't understand the confusion/sarcasm here. Rouben clearly stated it
was not standard. It is however a useful feature available to many
developers and there is no harm voicing the fact that it exists (along
with the fact that it is not standard as Rouben did) when there is no
standard solution and the information may help the OP.

What sarcasm? Rouben said it wasn't standard. Michael appeared to miss
that since he asked what standard header it aapeared in. Joe restated
that it's not part of C as such. What's your problem?

I said confusion/sarcasm, as in I didn't know whether he was confused or
being sarcastic. Given the reaction of most people here when someone
discusses something non-standard I don't think is unreasonable to assume
the latter (which I didn't).

Rob Gamble

[suman kar]

ro****@pc18.mat h.umbc.edu (Rouben Rostamian) wrote in message news:<cn******* ***@pc18.math.u mbc.edu>...

In article <pa************ ***********@net active.co.uk>,
Lawrence Kirby <lk****@netacti ve.co.uk> wrote:

On Sun, 14 Nov 2004 13:32:08 +0000, Rouben Rostamian wrote:

In article <T9Bld.58779$EZ .51910@okepread 07>,
Michael McGarry <mm******@nospa m.org> wrote:
Hi,

I am pretty sure this is not possible, but maybe somehow it is.

Given a variable, can I tell what type it is at runtime?
How would you want this information to be represented? How would you use
it? Remember that C is statically typed. You know at the point you use
a variable what type it is, you just have to look at the definition for
the variable.

Some compilers, like gcc, provide a construct named
typeof() which produces the object type.

AFAIK this is just a band-aid for macros, replicating a type in
another declaration or a cast - strictly a compile time thing. It doesn't
address the OP's question of a runtime test. Since C doesn't support
Runtime Type Information, inheritance or any sort of dynamic typing a
runtime test doesn't make much sense - it just tells you what you already
know.

Unfortunately,
(and inexplicably) typeof() has not found its way into
the C standard.

There may be the odd occasion where it is useful but don't see that these
are common enough to make it a language requirement.

Of course you are right in saying that a runtime operator for
getting an object's type doesn't make much sense in C.

I am not sure, however, if I would characterize gcc's typeof()
as a "band-aid for macros". Calling it band-aid implies that
there may be a better solution in sight. Look at:

#define swap(a,b) do \
{ typeof(a) swap_tmp = a; a = b; b = swap_tmp; } while(0)

The alternative is to write a different swap macro/function for
each different type. Which is the cleaner? Which is the band-aid?

One more alternative:rea ding up on K&R, they did it years ago without
any typeof operator.Hint:P ass the type as a parameter.
A more interesting and useful application of a typeof()
construct would be in the dynamic allocation of two-dimensional
arrays. Instead of having to supply multiple functions such as:

double **make_matrix_d ouble (size_t m, size_t n);
int **make_matrix_i nt (size_t m, size_t n);
complex **make_matrix_c omplex (size_t m, size_t n);
mystruct **make_matrix_m ystruct(size_t m, size_t n);

you may write a single make_matrix() macro for all types.
Very handy for numerical analysts working with matrix algebra.
I wouldn't dismiss this an "odd occasion where it is useful".

HTH.
Suman.