why c++ not support typeof()?

[Key9]

Hi all

Q1:

On reading source code of STL, I just confuse about why c++ not support
such a pesudo code ?

//pesudo code
int a = new int()£»
Typeof(a) b = new Typeof(a)()£»
Q2£º

NOT about c++:

How to read older post? for sample some one write on year 2002?
I tried google , no lucky.

thank you .

your key9

[Assertor]

Not like java, Anyone CAN NOT not know the realy type to be related an
object at the run time.
Think "void", "type casting", etc.

"void" can receive all of type.
"type casting" can many different type.

[Ben Pope]

Key9 wrote:

Hi all

Q1:

On reading source code of STL, I just confuse about why c++ not support
such a pesudo code ?

//pesudo code
int a = new int()£»
Typeof(a) b = new Typeof(a)()£»
Because C++ is statically typed.

You can produce similar effects at runtime with the "virtual
constructor" or factory method idioms.

You can produce similar effects which are statically bound, by using
templates.

Q2£º

NOT about c++:
Well then lets make it about C++.
How to read older post? for sample some one write on year 2002?
I tried google , no lucky.

You mean, how do you read archived posts of comp.lang.c++?

http://groups.google.com/group/comp.lang.c++

Ben Pope
--
I'm not just a number. To many, I'm known as a string...

[Michiel.Salters]

Key9 wrote:

Hi all

Q1:

On reading source code of STL, I just confuse about why c++ not support
such a pesudo code ?

//pesudo code
int a = new int();
Typeof(a) b = new Typeof(a)();

There was no proposal for this in 1998 when C++98 was introduced. It
may appear
in the next version, although probably by another name. (decltype,
IIRC, because
it's the *declared* type of 'a' that determines decltype(a))

Of course, an STL implementation make take advantage of the
implementation
and use __typeof today, if the compiler has it.

HTH,
Michiel Salters

[Alf P. Steinbach]

* Mi*************@tomtom.com:

Key9 wrote:

Hi all

Q1:

On reading source code of STL, I just confuse about why c++ not support
such a pesudo code ?

//pesudo code
int a = new int();
Typeof(a) b = new Typeof(a)();

There was no proposal for this in 1998 when C++98 was introduced. It
may appear
in the next version, although probably by another name. (decltype,
IIRC, because
it's the *declared* type of 'a' that determines decltype(a))

Of course you may not know, but, if you do know, or someone, whose
brilliant idea was it to /yet again/ disregard existing practice?

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[andy]

Key9 wrote:

Hi all

Q1:

On reading source code of STL, I just confuse about why c++ not support
such a pesudo code ?

//pesudo code
int a = new int()£»
Typeof(a) b = new Typeof(a)()£»

The next version of the boost distro:
http://www.boost.org
will support a typeof macro which will achieve this functionality with
some technicalities.

regards
Andy Little

[Phlip]

Ben Pope wrote:

//pesudo code
int a = new int()£»
Typeof(a) b = new Typeof(a)()£»

Because C++ is statically typed.

I thought Boost supported a huge inhumane cracker that does that.

--
Phlip
http://www.greencheese.org/ZeekLand <-- NOT a blog!!!

[Phlip]

andy wrote:

The next version of the boost distro:
http://www.boost.org
will support a typeof macro which will achieve this functionality with
some technicalities.

Is it in foreach.zip, here?

http://www.boost-consulting.com/vaul...ory=Algorithms

I would figure out for myself, but I can't seem to download the file.

(This is obviously my fault - not Boosts!!)

--
Phlip
http://www.greencheese.org/ZeekLand <-- NOT a blog!!!

[REH]

Alf P. Steinbach wrote:

* Mi*************@tomtom.com:

Key9 wrote:

Hi all

Q1:

On reading source code of STL, I just confuse about why c++ not support
such a pesudo code ?

//pesudo code
int a = new int();
Typeof(a) b = new Typeof(a)();

There was no proposal for this in 1998 when C++98 was introduced. It
may appear
in the next version, although probably by another name. (decltype,
IIRC, because
it's the *declared* type of 'a' that determines decltype(a))

Of course you may not know, but, if you do know, or someone, whose
brilliant idea was it to /yet again/ disregard existing practice?

I seem to recall an explanation was given for using decltype over
typeof, but I cannot find it. The reason is not mentioned in N1705.

REH

[Pavel Vozenilek]

"Phlip" wrote:

The next version of the boost distro:
http://www.boost.org
will support a typeof macro which will achieve this functionality with
some technicalities.

Is it in foreach.zip, here?

http://www.boost-consulting.com/vaul...ory=Algorithms

I would figure out for myself, but I can't seem to download the file.

No, it is not in foreach, it is different library.

You may download the fresh CVS or wait couple
of weeks for Boost 1.34 where it'l be released.

The library uses native typeof where available
(gcc) and emulation elsewhere.
The compile times for emulated typeof may be high.

/Pavel

[andy]

Pavel Vozenilek wrote:

You may download the fresh CVS or wait couple
of weeks for Boost 1.34 where it'l be released.

The library uses native typeof where available
(gcc) and emulation elsewhere.
The compile times for emulated typeof may be high.

Even for emulated typeof the compile times are not greatly problematic
as, AFAIK, a lot of effort has been spent on this area. The main
hurdle, which is required for portability, is the need to register a
type( and maybe associated types) with the typeof mechanism. Of course
registration can be a No-op, in native mode, on those platforms that
also support the 'native' mode.

regards
Andy Little

[andy]

REH wrote:

I seem to recall an explanation was given for using decltype over
typeof, but I cannot find it. The reason is not mentioned in N1705.

I think decltype preserves references, whereas typeof doesnt:

std::ostream& my_output();

decl_type(my_output()) t1;
typeof(my_output()) t2;

t1 is std::ostream&
t2 is std::ostream.

I think <---!!!

regards
Andy Little

[Michiel.Salters]

Alf P. Steinbach wrote:

* Mi*************@tomtom.com:

It (typeof) may appear in the next version, although probably by
another name. (decltype,
IIRC, because
it's the *declared* type of 'a' that determines decltype(a))

Of course you may not know, but, if you do know, or someone, whose
brilliant idea was it to /yet again/ disregard existing practice?

What existing practice? The name part? Or the behavior? When the EWG
looked
at the existing practice, it was discovered that there are really two
things that
they try to achieve. Because of this, existing practice was
inconsistent. The
EWG liked both, but decided that you can't have both things and a
single name.
AFAIK, the idea is still to have

auto x = expr; // where the type of x is "what you expect" and
decltype(expr) // where decltype(x) is really the type from the
declaration.

to cover the two common typeof cases. Existing practice is pretty much
anything in between.

HTH,
Michiel Salters

[Alf P. Steinbach]

* Mi*************@tomtom.com:

Alf P. Steinbach wrote:

* Mi*************@tomtom.com:

It (typeof) may appear in the next version, although probably by
another name. (decltype,
IIRC, because
it's the *declared* type of 'a' that determines decltype(a)) Of course you may not know, but, if you do know, or someone, whose
brilliant idea was it to /yet again/ disregard existing practice?

What existing practice? The name part?

The name part, since AFAIK there's no room for deviant behavior... ;-)

Or the behavior? When the EWG
looked
at the existing practice, it was discovered that there are really two
things that
they try to achieve. Because of this, existing practice was
inconsistent. The
EWG liked both, but decided that you can't have both things and a
single name.
AFAIK, the idea is still to have

auto x = expr; // where the type of x is "what you expect" and
decltype(expr) // where decltype(x) is really the type from the
declaration.

to cover the two common typeof cases. Existing practice is pretty much
anything in between.

Is it?

When I typed "gnu typeof" into the Firefox address line, I endeth up at
<url:
http://developer.apple.com/documentation/DeveloperTools/gcc-4.0.1/gcc/Typeof.html>.

I'm unaware of any existing practice that gives x above, in your
example, the /dynamic/ type of expr, or anything but the static type.

So this second thing you're referring to, I don't see it: what is it?

As I see it, there must be some COBOL saboteur on the committee...
--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[REH]

an**@servocomm.freeserve.co.uk wrote:

REH wrote:

I seem to recall an explanation was given for using decltype over
typeof, but I cannot find it. The reason is not mentioned in N1705.

I think decltype preserves references, whereas typeof doesnt:

std::ostream& my_output();

decl_type(my_output()) t1;
typeof(my_output()) t2;

t1 is std::ostream&
t2 is std::ostream.

I think <---!!!

regards
Andy Little

Well, since there is no standard definition of typeof, who's to say.
GCC's version does not. decltype not only preserves references, if
given an lvalue it "returns" a reference type.

REH

[Kaz Kylheku]

Key9 wrote:

On reading source code of STL, I just confuse about why c++ not support
such a pesudo code ?

Indeed, why not have an operator which extracts type information from
an expression which can be used in a cast or declaration?

Because it would be way too easy to implement, and way too useful.

That is not the C and C++ way.