On Wednesday, 9 September 2015 at 14:57:26 UTC, Adam D. Ruppe
wrote:
On Wednesday, 9 September 2015 at 07:19:58 UTC, Q wrote:
Can I be sure that the Handle is destroyed as soon as the
class is destroyed?
It will do that automatically.
Like the others said, you won't be sure when the class is
destroyed unless you have the user code take ownership of it.
(This btw is the same as C++, just in C++ the ownership syntax
is a wee bit shorter.)
C++:
class Foo {
public:
Foo() { /* acquire */ }
~Foo() { /* destroy */ }
};
void useFoo(Foo* foo) { }
// pretend I did the header separation here
int main() {
Foo foo;
useFoo(&foo);
return 0;
}
D:
--
module foo;
class Foo {
private this() { /* acquire */ }
~this() { /* destroy */ }
}
struct OwnedFoo(F) {
F foo;
alias foo this;
~this() {
.destroy(foo);
}
@disable this(this) {}
}
auto create(F, T...)(T t) if(is(F : Foo)) {
return OwnedFoo!F(new F(t));
}
--
--
module main;
import foo;
void useFoo(Foo foo) {}
void main() {
auto foo = create!Foo();
}
---
The code is a bit longer since the owned pointer in the
standard library isn't exactly what I wanted, but you could use
std.typecons.Unique too. (Actually, it does offer a bit more
safety in reference escaping than mine. But mine is the closest
to C++ default).
The private constructor means it won't let you bypass the owned
factory when creating it. A bit extra code in foo means all
uses of it will be simple like in main.
Just don't store the reference after it is destroyed, just like
you would need to be careful with in C++. Using the library
Unique will help you get this right too if you want to learn
that.
But in C++, classes and structs are value types _and_
extendable.There is no pressure to heap allocate a class. Of
course, if I do that, I use a unique_ptr (shared_ptr is almost
everytime misplaced).
But since D has a GC and (per default) force to heap allocate a
class. So IMO the GC should also destroy it, everything else is
just awkward. I don't want to hack around in a new language. I
think Rust offers my all I want. But thanks for the explanation.
