struct to/from void, object to/from void

[Era Scarecrow]

On Monday, 30 April 2012 at 05:07:04 UTC, Ali Çehreli wrote:
> You mean "object"? A class variable is just a handle to the 
> class object. Class variables are implemented as pointers, so 
> yes, they will be the size of a pointer. Since I suspect that 
> the pointers are 4 bytes on the OP's 32-bit system, I don't see 
> any fatness there. It is just a plain pointer.

   I was thinking the 'string' which was a fat pointer, but likely 
I misread it and assumed the size was referring to the object's 
contents. 4bytes would be a single pointer, so my mistake on that 
part.


> The object itself has some data that makes it behave like its 
> actual type but I wouldn't be surprised if it contained a 
> virtual function table pointer just like in C++. But note that 
> the object, not the variable is fat in that sense.

  But unlike in C++, it only incorporates it if you add 'virtual', 
so the up and down casting can revert to it's previous version. 
I've read about it more than used it so..

//c++ - not tested..
class Base {
   void func() { stdout << "base!";}
}

bass Derived : Base {
   virtual void func() {stdout << "derived (virtual)";}
}

void main(){
   //use pointers? I can't remember...
   Derived d = new Derived;
   base b = (Base) d;
   b.func(); //Logically should call the derived one, but since 
there's no virtual table, we get the base's one instead!!
}

  Inside the derived class it's a virtual call, change it back to 
it's base and it loses that extra information. You may be able to 
up/down cast, but it's a problem in C++. One more reason I don't 
use C++ if I don't have to.

> Correction: It is actually an upcast, which does not require 
> the explicit cast anyway.

  I am getting up and down backwards. My bad..

> I find the following message more descriptive:
>
>   assert(ba !is null, "a is not actually a BA?");
>
> To be more pedantic, 'a' is neither an A nor a BA. It is a 
> variable that provides access to an object through the A 
> interface.