gistfile1.txt

fn decCountInc(self: ?*SnekObject, allocator: std.mem.Allocator) void {
        if (self == null) {
            return;
    }
        self.?.referenceCount -= 1;
        if (self.?.referenceCount == 0) {
            SnekObject.refCountFree(self.?, allocator);
        }
        
 }


test "testing decrement ref count" {
    const allocator = std.testing.allocator;
    const x = SnekObject.newSnekInteger(allocator, 1);
    try expect(x.?.referenceCount == 1);
    SnekObject.refCountInc(x);
    SnekObject.decCountInc(x, allocator);
    try expect(x.?.referenceCount == 1);
    SnekObject.decCountInc(x, allocator);
    // If I call this multiple times after this like this
  SnekObject.decCountInc(x, allocator);
  SnekObject.decCountInc(x, allocator);
// This will result in Segfault
}

Freeing memory will never make your pointers null. There are bugs such as “double free” or memory corruption when keeping pointers to memory that was freed

You can’t easily check if an “object” was freed or not AFAIK (I mean if the pointer is still valid). You could implement your own allocator if you need that information but that’s a bit extreme.
Usually the init / deinit pattern helps with remembering to always free after use (and not free twice or avoid using the freed memory after free).

Usually you think about ownership of which part of the code handles the resource allocation, moves ownership and then the owner has to handle free.
With implementing a garbage collection and reference counting that’s the difficult part as there’s no clear owner of the object being passed around freely.

Not sure how I would implement a check if it’s freed or not. I think you could just free only when you decrement from 1 to 0, but remember to always add 1 when using the object and remove 1 when you’re done.

The function doing the allocation will move ownership to the caller hence it should pre-increment 1 (that way you can check it’s not zero which is not freed yet)

Thank you @Zorgatone
This is really helpful