On 13/10/2024 6:12 PM, Salih Dincer wrote:
On Saturday, 12 October 2024 at 13:11:52 UTC, Richard (Rikki) Andrew
Cattermole wrote:
You are not wrong, when it is a struct, it is being heap allocated.
Sorry for prolonging the topic. I am very curious about your answers
along with your patience...
Can we say that structs are in the stack (LIFO) as long as we do not use
the new operator? Also, should using scope in structures cause a change?
I never seen it does! However, there is no incompatibility here: Whether
it is a class or a struct, when you use the new operator, the first run
constructor becomes the first run destructor with FIFO logic.
You can reverse this situation with scope (but only in classes). By
reverse I don't mean LIFO! In fact, the correct expression is that when
you are done with the object, it is removed.
Thanks, SDB@79
Sorry for not replying sooner, COVID has not been a fun virus for my
mind to have.
When a variable is declared with a struct that needs cleanup, it
effectively rewrites the following statements into a try finally:
```d
void main()
{
S s = 0;
try
{
if (true)
return 0;
}
finally
s.~this();
return 0;
}
```
There are simplifications of this, without the need for the try finally,
but we can ignore it for the purposes of this explanation.
The same can be seen with a class that was allocated on the stack:
```d
void main()
{
scope C c = new C;
try
{
if (true)
return 0;
}
finally
delete c;
return 0;
}
```
Nested:
```d
void main()
{
scope C c = new C;
try
{
S s = 0;
try
{
if (true)
return 0;
}
finally
s.~this();
}
finally
delete c; // aggregate dtor is called
return 0;
}
```
How nesting destroys fields:
```d
class C : Object
{
S s;
scope ~this() // user dtor
{
}
scope ~this() // field dtor
{
this.s.~this();
}
scope ~this() // aggregate dtor
{
// user dtor , field dtor
this.~this() , this.~this();
}
}
```
This should cover the ordering on the stack. If you have any further
questions about it please ask.
---------------------------------------------
> Also, should using scope in structures cause a change?
> I never seen it does!
The scope attribute in a declaration body such as a struct, class or
union applies to the method, for its this pointer. It does not apply to
the fields.
Generally speaking, scope should not be on a type or field declaration.
Good:
```d
struct S {
int fields;
private shared int* thing;
export @safe nothrow @nogc:
this() scope {}
void method1() scope {}
scope { // ok
void method2() {}
}
scope: // no indication at function that it is applied, not great
void method3() {}
}
```
Bad:
```d
struct S {
export @safe nothrow @nogc scope:
int fields;
this() {}
void method() {}
}
shared scope struct S {
export @safe nothrow @nogc:
int fields;
this() {}
void method() {}
}
```
