• z (76/97) Aug 16 2008 Try my luck here.

z <z gg.com> writes:

Try my luck here.

== Repost the article of z (z gg.com)
== Posted at 2008/08/15 20:36 to digitalmars.D

== Quote from z (z gg.com)'s article
 Hi,
 I'm reading http://digitalmars.com/d/2.0/memory.html
 and try to combine "Free Lists" and "Explicit Class Instance Allocation".
 So instead of:
 void test()
 {
     Foo f = Foo.allocate();
     ...
     Foo.deallocate(f);
 }
 I can just write as normal:
 void test()
 {
     Foo f = new Foo();
     ...
     delete Foo;
 }
 But the simple code I wrote seg faults. Is this a compiler bug? or I'm doing
 something wrong? or can this thing be done at all?
 Thanks.
  << custom.d >>

the code:

$ cat custom.d
import std.stdio;
import std.c.stdlib;
import std.outofmemory;
import std.gc;

class Bar {
    public void fun() {
      printf("Bar\n");
    }
}

class Foo : Bar {
    string name;

    this() {
        printf("my ctor\n");
    }

    ~this() {
        printf("my dtor\n");
        // suppose I don't do anything here
    }

    public override void fun() {
        writeln(name);
    }

    new(size_t sz)
    {
        printf("my new\n");
        Foo f;
        if (freelist)
        {   f = freelist;
            freelist = f.next;
            return cast(void*)f;   // I know that ctor will be called again on
f.
Is there any way to skip :-) ?
        }

        void* p;
        p = std.c.stdlib.malloc(sz);
        if (!p)
            throw new OutOfMemoryException();
        //std.gc.addRange(p, p + sz);
        return p;
    }

    delete(void* p)
    {
        printf("my del\n");
        // suppose I just save it for reuse, instead of free memory
        Foo f = cast(Foo)p;
        deallocate(f);
        printf("saved!\n");
        // try to call some method, see if it still works:
        f.fun();  // Segmentation fault here. Is there any way to make this
work?
        // I run thru the debugger, and found f's attritube is not changed.
        // so what's going wrong?
        // is this because even after I provided my own 'delete' and '~this',
        // compiler still inserted some extra cleanup code?
    }

    static Foo freelist;                // start of free list

    static void deallocate(Foo f)
    {
        f.next = freelist;
        freelist = f;
    }

    Foo next;           // for use by FooFreeList
}

int main() {
  Foo foo;
  foo = new Foo();
  foo.name = "old-guy";
  foo.fun();
  delete foo;

  foo = new Foo();
  foo.fun();

  return 0;
}