Print name of typedef:ed type

[Eric Lilja]

Hello, in my c++ program I have the following "block":
#if defined __GNUC__ && defined NOT_PEDANTIC
typedef unsigned long long inttype;
#elif defined _MSC_VER
typedef unsigned __int64 inttype;
#else
typedef unsigned long inttype;
#endif

I'm wondering if there's a way, without resorting to the preprocessor,
to print the actual type (its name) of inttype when the program is
running? In the meantime I'm printing what
numeric_limits<inttype>::max() returns to give some hint.

- Eric

[Pete Becker]

On 2007-11-14 13:56:21 -0500, Eric Lilja <mi********@gmail.comsaid:

Hello, in my c++ program I have the following "block":
#if defined __GNUC__ && defined NOT_PEDANTIC
typedef unsigned long long inttype;
#elif defined _MSC_VER
typedef unsigned __int64 inttype;
#else
typedef unsigned long inttype;
#endif

I'm wondering if there's a way, without resorting to the preprocessor,
to print the actual type (its name) of inttype when the program is
running? In the meantime I'm printing what
numeric_limits<inttype>::max() returns to give some hint.

Since you're already relying on the preprocessor, why do you object to
using it? Just add a string literal to each branch of your if ladder.

--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)

[Victor Bazarov]

Eric Lilja wrote:

Hello, in my c++ program I have the following "block":
#if defined __GNUC__ && defined NOT_PEDANTIC
typedef unsigned long long inttype;
#elif defined _MSC_VER
typedef unsigned __int64 inttype;
#else
typedef unsigned long inttype;
#endif

I'm wondering if there's a way, without resorting to the preprocessor,
to print the actual type (its name) of inttype when the program is
running? In the meantime I'm printing what
numeric_limits<inttype>::max() returns to give some hint.

First off, there is no "long long" (signed or not) in C++. There is
no __int64 in C++ either.

You could try using 'typeid(expression).name()' to get the string
that contains the implementation's best approximation to the type of
the expression. I tried it with VC++ v8, and it gives back the actual
type.

There is no clean way in C++ language itself, though, since the 'name'
member of 'std::typeinfo' is allowed to return an empty string.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Eric Lilja]

On 14 Nov, 20:03, "Victor Bazarov" <[e-mail]:

>
First off, there is no "long long" (signed or not) in C++. There is
no __int64 in C++ either.

I know, that's why I'm using the preprocessor to activate compiler
extensions where available.

>
You could try using 'typeid(expression).name()' to get the string
that contains the implementation's best approximation to the type of
the expression. I tried it with VC++ v8, and it gives back the actual
type.

There is no clean way in C++ language itself, though, since the 'name'
member of 'std::typeinfo' is allowed to return an empty string.

I see, I will try it and see what happens on the other compilers I'm
targeting. VC++ v8 is one of them so at least I get the desired output
under that compiler it seems.

- Eric

[Eric Lilja]

On 14 Nov, 20:01, Pete Becker <[e-mail]:

On 2007-11-14 13:56:21 -0500, Eric Lilja <[e-mail]:

Hello, in my c++ program I have the following "block":
#if defined __GNUC__ && defined NOT_PEDANTIC
typedef unsigned long long inttype;
#elif defined _MSC_VER
typedef unsigned __int64 inttype;
#else
typedef unsigned long inttype;
#endif

I'm wondering if there's a way, without resorting to the preprocessor,
to print the actual type (its name) of inttype when the program is
running? In the meantime I'm printing what
numeric_limits<inttype>::max() returns to give some hint.

Since you're already relying on the preprocessor, why do you object to
using it? Just add a string literal to each branch of your if ladder.

--
Pete

Ah, good idea, I didn't think of that. I was trying to avoid using the
preprocessor again around the cout-statements and with your solution I
will avoid having to do just that. But I will try Victor's suggestion
as well just to see what happens. Thanks for your help and your quick
replies!

- Eric

[James Kanze]

On Nov 14, 8:03 pm, "Victor Bazarov" <[e-mail]:

Eric Lilja wrote:

Hello, in my c++ program I have the following "block":
#if defined __GNUC__ && defined NOT_PEDANTIC
typedef unsigned long long inttype;
#elif defined _MSC_VER
typedef unsigned __int64 inttype;
#else
typedef unsigned long inttype;
#endif

I'm wondering if there's a way, without resorting to the
preprocessor, to print the actual type (its name) of inttype
when the program is running? In the meantime I'm printing
what numeric_limits<inttype>::max() returns to give some
hint.

First off, there is no "long long" (signed or not) in C++.
There is no __int64 in C++ either.

There's neither of them in *standard* C++, but since long long
is part of C90, and will be part of the next version of C++,
it's pretty much universal today, and can be considered "C++"
(but you'll need -Wno-long-long to get it with g++).

You could try using 'typeid(expression).name()' to get the
string that contains the implementation's best approximation
to the type of the expression. I tried it with VC++ v8, and
it gives back the actual type.

VC++ tries to do something useful with it. So does Sun CC.
G++, on the other hand, returns the string it uses when mangling
names, which is usually pretty useless. (For a long long, I get
"x".)

There is no clean way in C++ language itself, though, since
the 'name' member of 'std::typeinfo' is allowed to return an
empty string.

Or gibberish. Some compilers have decided that gibberish is the
way to go.

--
James Kanze (GABI Software) email:ja*********@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Victor Bazarov]

James Kanze wrote:

On Nov 14, 8:03 pm, "Victor Bazarov" <[e-mail]:

>You could try using 'typeid(expression).name()' to get the
string that contains the implementation's best approximation
to the type of the expression. I tried it with VC++ v8, and
it gives back the actual type.

VC++ tries to do something useful with it. So does Sun CC.
G++, on the other hand, returns the string it uses when mangling
names, which is usually pretty useless. (For a long long, I get
"x".)

>There is no clean way in C++ language itself, though, since
the 'name' member of 'std::typeinfo' is allowed to return an
empty string.

Or gibberish. Some compilers have decided that gibberish is the
way to go.

I believe the point is that it's the same gibberish every time for
the same type. Furthermore, if it's "x" for 'long long', then it
is going to be "x" for a typedefed synonym of 'long long'. That's
*relatively* useful.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Joel Yliluoma]

On Wed, 14 Nov 2007 11:23:28 -0800, Eric Lilja wrote:

On 14 Nov, 20:03, "Victor Bazarov" <[e-mail]:

>>
First off, there is no "long long" (signed or not) in C++. There is
no __int64 in C++ either.

I know, that's why I'm using the preprocessor to activate compiler
extensions where available.

You could use int_least64_t and/or int_fast64_t from cstdint.

--
Joel Yliluoma - http://iki.fi/bisqwit/