void pointer syntax

[Ali Çehreli]

On 05/15/2012 07:01 PM, Stephen Jones wrote:

 > Using Object gives exactly the same problem as the Object super class
 > does not have vcount variable.

But Object is better than void* because the latter has no safety and 
completely unusable. All you can do with a void* is to cast it back to 
its own type. If you don't keep type information somehow, nobody knows 
what the original type was.

 > Casting is not a solution

That is the only solution. It may be somehow wrapped, but you must cast 
void* to a useful type first.

 > because the
 > reason for throwing different sorts of widgets into a single array was
 > so I did not have to track what each type of object was;

Yeah, great! That's polymorphism. Great. You keep a Widget[] and use it.

 > not tracking
 > what each object in the array is I have no means of knowing what to cast
 > each Widget in the array to.

Exactly! :) Either you or the compiler must keep track of it. void* 
removes any trace of type information.

 > If some one knows void pointer syntax that would be helpful.

import std.stdio;

void main()
{
     int i;
     double d;

     void*[] array;
     array ~= cast(void*)&i;
     array ~= cast(void*)&d;

     foreach (address; array) {
         writeln("I don't know what type of object is at ", address);
     }
}

 > As I
 > understand it there is a type called size_t that takes the address of as
 > a a value.

No. size_t is suitable to represent concepts like size, quantity, etc. 
Concepts that are supposed to be never less than zero.

 > Can I make an array of these and simply initialize each with
 > &button1, &cursor, etc? Also, how is size_t freed?

You can but it would make no sense:

import std.stdio;

void main()
{
     int i;
     double d;

     size_t[] array;
     array ~= cast(size_t)&i;
     array ~= cast(size_t)&d;

     foreach (size; array) {
         writeln("I don't know what to do with this amount: ", size);
     }
}

Getting back to your original question, here is another solution where 
Widget is a class (not an interface) that has a vertCount member. It 
makes it necessary that the subclasses construct it with that information:

import std.stdio;

class Widget{
     abstract void draw();

     size_t vertCount;

     this(size_t vertCount)
     {
         this.vertCount = vertCount;
     }
}

class Button : Widget{
     override void draw(){}

     this()
     {
         super(100);
     }
}

class Cursor : Widget{
     override void draw(){}

     this()
     {
         super(200);
     }
}

void main()
{
     Widget[] widgets;
     widgets~=new Button();
     widgets~=new Cursor();

     foreach(Widget w; widgets){
         writeln(w.vertCount);
     }
}

Ali

-- 
D Programming Language Tutorial: http://ddili.org/ders/d.en/index.html