Bill Baxter wrote:
On Mon, Mar 9, 2009 at 7:12 AM, John Simon <[email protected]> wrote:
Sean Kelly Wrote:
John Simon wrote:
Sean Kelly Wrote:
Oh, I should mention that I'm not sure how the compiler would handle
this scenario:
class A { byte[16]; }
class B { byte[32]; }
class C {
this( bool b ) {
if( b ) o = new A;
else o = new B;
}
scope Object o;
}
If I had to guess I'd say that the compiler would either reserve the max
size necessary to store both A or B, or that in non-trivial cases it
just wouldn't bother with reserving space for o at all.
Wrong. The Object is constructed when it comes into scope, and destructed when
it leaves scope. Classes can't have an 'opAssign', instead the reference is
reassigned. Since the reference is invariant/immutable here, this throws a
compile time error.
I'm talking about a proposed new feature, not an existing one. Please
take this example in context.
Sorry man, I thought you were disputing with me. My apologies. Let me rephrase.
I believe that 'scope' declared objects shouldn't allow an assignment of a
derived type. Reasoning being that there wouldn't be enough stack space
allocated for it.
So in your example above, Object could only recieve a 'new Object', and nothing
further down in the hierarchy.
I'm pretty sure that assigning to a scope class on the stack is not
done by copying the memory. I'm pretty sure what happens is basically
something like follows. This scope statement:
scope foo = new TheClass;
Basically becomes this:
static ubyte[sizeof_TheClass] _mem;
auto foo = new(_mem.ptr) TheClass;
To that add:
scope(exit) foo.~this();
I don't think there's a syntax for destructor invocation. Never liked
scope that much. Extremely dangerous for such a cute syntax.
Andrei