D programming Language
Download 1.66 Mb.
|
- Navigate this page:
- Explicit Class Instance Allocation
- Mark/Release
- RAII (Resource Acquisition Is Initialization)
Reference CountingThe idea behind reference counting is to include a count field in the object. Increment it for each additional reference to it, and decrement it whenever a reference to it ceases. When the count hits 0, the object can be deleted. D doesn't provide any automated support for reference counting, it will have to be done explicitly. Win32 COM programming uses the members AddRef() and Release() to maintain the reference counts.
import c.stdlib; import outofmemory; import gc; class Foo { new(uint sz) { void* p; p = c.stdlib.malloc(sz); if (!p)
throw new OutOfMemory(); gc.addRange(p, p + sz); return p; }
{ if (p)
{ gc.removeRange(p); c.stdlib.free(p); } }
The critical features of new() are:
The critical features of delete() are:
If memory is allocated using class specific allocators and deallocators, careful coding practices must be followed to avoid memory leaks and dangling references. In the presence of exceptions, it is particularly important to practice RAII to prevent memory leaks. Mark/ReleaseMark/Release is equivalent to a stack method of allocating and freeing memory. A 'stack' is created in memory. Objects are allocated by simply moving a pointer down the stack. Various points are 'marked', and then whole sections of memory are released simply by resetting the stack pointer back to a marked point. import c.stdlib; import outofmemory;
{ static void[] buffer; static int bufindex; static const int bufsize = 100; static this() { void *p; p = malloc(bufsize); if (!p)
throw new OutOfMemory; gc.addRange(p, p + bufsize); buffer = p[0 .. bufsize]; }
{ if (buffer.length) { gc.removeRange(buffer); free(buffer); buffer = null; } }
{ void *p; p = &buffer[bufindex]; bufindex += sz; if (bufindex > buffer.length) throw new OutOfMemory; return p; }
{ assert(0); } static int mark() { return bufindex; } static void release(int i) { bufindex = i; } }
{ int m = Foo.mark(); Foo f1 = new Foo; // allocate Foo f2 = new Foo; // allocate ... Foo.release(m); // deallocate f1 and f2 } The allocation of buffer[] itself is added as a region to the gc, so there is no need for a separate call inside Foo.new() to do it. RAII (Resource Acquisition Is Initialization)RAII techniques can be useful in avoiding memory leaks when using explicit allocators and deallocators. Adding the auto attribute to such classes can help. Allocating Class Instances On The StackAllocating class instances on the stack is useful for temporary objects that are to be automatically deallocated when the function is exited. No special handling is needed to account for function termination via stack unwinding from an exception. To work, they must not have destructors. import c.stdlib; class Foo { new(uint sz, void *p) { return p; }
{ assert(0); } }
{ Foo f = new(c.stdlib.alloca(Foo.classinfo.init.length)) Foo; ... }
Directory: upload upload -> 587 Return function, r i(X) r i(0) r i(1) r i(2) r i(3) 1 0 2 4 6 Thermal Station, I 2 0 1 5 6 3 0 3 5 6 10 upload -> Department of science and humanities department of mathematics part-a questions and answers upload -> The Case Against the nypd’s Quota-Driven ‘Broken Windows’ Policing What Is It? upload -> For want of a nail upload -> Traditional British values upload -> Tv shows, Made for tv movies, Mini Series & Internet Programs Shot at Paramount Ranch upload -> Ownership Models There are two different types of ownership models upload -> Police Militarization upload -> City of rising star regular meting thursday, july 14, 2016 upload -> Township of winfield Download 1.66 Mb. Share with your friends:
|