On Fri, Nov 21, 2014 at 10:30:51PM +0000, Eric via Digitalmars-d-learn wrote:
> On Friday, 21 November 2014 at 22:25:32 UTC, anonymous wrote:
> >On Friday, 21 November 2014 at 22:15:37 UTC, Eric wrote:
[...]
> >>Is there a way I can check the type of x without doing
> >>a string comparison?
> >>
> >>-Eric
> >
> >assert(typeid(x) == typeid(Y));
>
> Thanks. That works. I have't quite mastered the whole
> is/typeof/typeid thing yet.
Binary `is` (i.e., `a is b`) is for comparing two references for
equality. It returns true if two class reference point to the same
object; false otherwise. But you probably already know this.
Unary `is` (`is(...)`) is a monstrous maze of obscure syntax, that's
best learned on a case-by-case basis. :-) But in this particular case,
it's basically to provide a context for comparing types, since types
aren't actual objects at runtime. So you can't write `if (typeof(a) ==
typeof(b))`, for example, because types aren't objects. Instead, you
have to write `if (is(typeof(a) == typeof(b)))`.
`typeof` is to extract types at compile-time. It returns the *declared*
type of the variable (which may not be the most derived class if you
assigned a derived object to a base class reference).
`typeid` is to introspect types at runtime. It returns the most derived
type of the object, even if the declared type is a base class. The
returned type is an actual runtime object -- since at compile-time, the
most derived type may not be known, so it's not representable as an
actual type at compile-time. Instead, the D runtime returns a TypeInfo
object that corresponds with the runtime type of the object. So you
don't need to (and shouldn't) use `is(...)` when comparing typeid's.
In short:
To compare (declared) types at compile time:
is(typeof(x) == typeof(y)) // x has the same (declared) type as y
is(typeof(x) : typeof(y)) // x implicitly converts to y
To compare (actual) types at runtime:
typeid(x) == typeid(y) // x has the same (actual) time as y
cast(B)x !is null // x is a derived class instance of base class B
There are many other cases, of course, but these are the pertinent ones
in the context of your original question.
T
--
Never wrestle a pig. You both get covered in mud, and the pig likes it.
