Re: Stupid scope destruction question

[Denis Shelomovskij]

20.09.2012 13:27, Denis Shelomovskij пишет:
Is there any guaranties that `ScopeTemp` will not be destroyed before
`f` call because it isn't used?
---
struct ScopeTemp
{
     ...
     // allocates value
     this(...) { ... }
     @property void* value() { ... }

     // destroys value
     ~this() { ... }
}

void f(void* ptr) { ... }

void main()
{
     f(ScopeTemp(...).value);
}
---
According to http://dlang.org/struct.html#StructDestructor
"Destructors are called when an object goes out of scope."
So I understand it as "it will not be destroyed before scope exit even
if not used". Is it correct?

So the question is if `ScopeTemp`'s scope is `main` scope, not some
possibly generated "temp scope" (don't now what documentation statements
prohibit compiler from doing so).


Working code:
---
import std.exception;
import std.c.stdlib;

struct ScopeTemp
{
     private int* p;
     // allocates value
     this(int i)
     in { assert(i); }
     body { *(p = cast(int*) enforce(malloc(int.sizeof))) = i; }

     @disable this(this);

     @property int* value() { return p; }

     // destroys value
     ~this() { *p = 0; p = null; /*free(p);*/ }
}

void f(int* ptr)
{
     assert(*ptr == 1);
}

void main()
{
     f(ScopeTemp(1).value);
}
---

Wow, this `main` works fine too:
---
// same ScopeTemp definition as above

int* gptr;

void f(int* ptr)
{
    assert(*ptr == 1);
    gptr = ptr;
}

void g()
{
    assert(*gptr == 0);
}

void main()
{
    f(ScopeTemp(1).value);
    // Here `ScopeTemp` value is already destroyed
    g();
}
---

So `ScopeTemp`'s scope definitely isn't a `main` scope. So the question: 
what do we know about this "temp scope"?

--
Денис В. Шеломовский
Denis V. Shelomovskij