object lifetimes in swift

Question

As a swift noob, and coming from C++, I wonder why the following prints 'BOOM!!':

var text = ""
class ArrayHandle {
    var array = Array()
    init() {
        text = "success"
    }
    deinit {
        text = "BOOM!!"
    }
}
struct Array { var buffer = Buffer() }
struct Buffer { func doStuff() { print(text)} }
var buffer = ArrayHandle().array.buffer.doStuff()

Apparently the deinit is called before the text is printed...

When you change the code to:

var handle = ArrayHandle()
handle.array.buffer.doStuff()

it prints the expected 'success'

Is there a way to force developers to use a var to store an object, or is that just a hidden bug that may fail in the future?

1.3k

Posted by

Marleen70

Reply

Add a Comment

Answer 1

If there is no exact control over the lifetime of an object in swift

There is.

When you declare a var or const, it remains referenced (and counted in ARC) as long as the block of its scope remains loaded.

For instance:

let handle = ArrayHandle()

if it is defined in a func, it stays referenced as long as you did not exit the func.

In a closure, as long you have not exited the closure (unless you declare the closure as escaping, then it survives after leaving.

In an if statement, as long as you are in the if statement.

Posted by

Claude31

thank you for clearing that up for me!

—
Marleen70

Add a Comment

Answer 2

Really interesting.

My understanding: when you call

var buffer = ArrayHandle().array.buffer.doStuff()

or just

ArrayHandle().array.buffer.doStuff()

ArrayHandle() instance is no more needed once you've got a reference to array. So compiler may continue with array.buffer with no need of the instance.

As there is no other reference to this ArrayHandle() instance, it can be deallocated and deinit is called automatically.

But if you declare a var handle, then it cannot be deallocated by ARC and thus deinit is not called at this point.

That's detailed in swift language Deinitializers in Action. But not with the detail on what happens in a sequence of references like here.

Posted by

Claude31

This may be an interesting read: https://stackoverflow.com/questions/68731011/when-is-deinit-exactly-called-in-swift

—
Claude31

Add a Comment

Answer 3

C++ has no ARC mechanism. I guess the behaviour comes from ARC in Swift.

I did a few more tests:

Just ArrayHandle class:

class ArrayHandle {
    init() {
        print("init")
        text = "success"
    }
    deinit {
        print("deinit")
        text = "BOOM!!"
    }
    func doStuff() {  // Moved inside
        print(text)
    }
}
ArrayHandle().doStuff()

You get the expected log:

init
success
deinit

Explanation: To call doStuff(), compiler needs to keep ArrayHandle(), it cannot deallocate ArrayHandle() yet. Hence, ARC cannot deinit.

Keep Buffer only:

struct Buffer {
    func doStuff() {
        print(text)
    }
}

class ArrayHandle {
    var buffer = Buffer()
    init() {
        print("init")
        text = "success"
    }
    deinit {
        print("deinit")
        text = "BOOM!!"
    }
}
ArrayHandle().buffer.doStuff()

You get the BOOM:

init
deinit
BOOM!!

Here, I understand that compiler loads an ArrayHandle instance, aka temporary.

let handle = ArrayHandle()

But does not create this permanent reference (just as if not counting in ARC counter)

Then it loads buffer, aka

let buffer = ArrayHandle().buffer

At this stage, temporary handle is no more referenced anywhere (we have not declared a var, it is just temporary by the compiler). Hence ARC can deallocate immediately and deinit is called. Then doStuff() is called on buffer, after deinit.

For what it's worth. Maybe some deep expert in Swift may confirm or deny this simplistic analysis ?

Posted by

Claude31

Ok, I understand now why the 'temporary' gets a deinit() call before I would like it to. What I still don't get, is why the same thing isn't happening when it is put inside a var, as that var is also no longer being referenced, at what seems to me to be the exact same point in the code. Is this a 'lucky coincidence', aka hidden bug, waiting to come out of hiding when some part of ARC is changed in the compiler?

If there is no exact control over the lifetime of an object in swift, how would you go about implementing the C++ concept of RAII in swift?

—
Marleen70

Add a Comment

Answer 4

If there is no exact control over the lifetime of an object in swift

There is.

When you declare a var or const, it remains referenced (and counted in ARC) as long as the block of its scope remains loaded.

For instance:

let handle = ArrayHandle()

if it is defined in a func, it stays referenced as long as you did not exit the func.

In a closure, as long you have not exited the closure (unless you declare the closure as escaping, then it survives after leaving.

In an if statement, as long as you are in the if statement.

Posted by

Claude31

thank you for clearing that up for me!

—
Marleen70

Add a Comment

object lifetimes in swift

Accepted Reply

Replies