Initializer list and default constructor

[FelipeParticipant]

Hi!

I don’t know if this has been talked about but is there a plan to add initializer list like C++ to mx2 constructors?

Also I noticed there isn’t a concept of default constructor on mx2. Any plans on that, this would be nice specially for Structs.

I comment this issues because I started porting a game library I’ve written in C++ which includes some custom collections, memory allocators and base structures. I wanted to write everything in MX2

The first thing I decided to port was my doubly linked intrusive list which ported to MX2 looks like this:

Monkey

Struct IntrusiveList<T> Method New(_pOwner:T Ptr = Null) pPrev = Varptr Self pNext = Varptr Self pHead = Varptr Self pOwner = _pOwner End Method Remove:Void() pPrev->pNext = pNext pNext->pPrev = pPrev pPrev = Varptr Self pNext = Varptr Self pHead = Varptr Self End Method InsertTail:Void(pTarget:IntrusiveList<T> Ptr) Local pTargetHead:IntrusiveList<T> Ptr = pTarget->pHead Remove() pNext = pTargetHead pPrev = pTargetHead->pPrev pTargetHead->pPrev = Varptr Self pPrev->pNext = Varptr Self pHead = pTargetHead->pHead End ' .... Some other methods go here Field pPrev:IntrusiveList<T> Ptr Field pNext:IntrusiveList<T> Ptr Field pHead:IntrusiveList<T> Ptr Field pOwner:T Ptr End

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

Struct IntrusiveList<T> Method New(_pOwner:T Ptr = Null) pPrev = Varptr Self pNext = Varptr Self pHead = Varptr Self pOwner = _pOwner End Method Remove:Void() pPrev->pNext = pNext pNext->pPrev = pPrev pPrev = Varptr Self pNext = Varptr Self pHead = Varptr Self End Method InsertTail:Void(pTarget:IntrusiveList<T> Ptr) Local pTargetHead:IntrusiveList<T> Ptr = pTarget->pHead Remove() pNext = pTargetHead pPrev = pTargetHead->pPrev pTargetHead->pPrev = Varptr Self pPrev->pNext = Varptr Self pHead = pTargetHead->pHead End ' .... Some other methods go  here Field pPrev:IntrusiveList<T> Ptr Field pNext:IntrusiveList<T> Ptr Field pHead:IntrusiveList<T> Ptr Field pOwner:T Ptr End

For testing I did something like this. A simple Int list.

Monkey

Struct IntValue Method New(_value:Int) value = _value node = New IntrusiveList<IntValue>(Varptr Self) End Field value:Int Field node:IntrusiveList<IntValue> End Function Main:Void() Local root:IntrusiveList<IntValue> = New IntrusiveList<IntValue>(Null) Local a:IntValue = New IntValue(0) ' Crash here a.node.InsertTail(Varptr root) End

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

Struct IntValue Method New(_value:Int) value = _value node = New IntrusiveList<IntValue>(Varptr Self) End Field value:Int Field node:IntrusiveList<IntValue> End   Function Main:Void() Local root:IntrusiveList<IntValue> = New IntrusiveList<IntValue>(Null) Local a:IntValue = New IntValue(0) ' Crash here a.node.InsertTail(Varptr root) End

This was crashing. I immediately started looking at the generated code and I found why it was crashing. The reason was this line in IntValue

Monkey

node = New IntrusiveList<IntValue>(Varptr Self)

1	node = New IntrusiveList<IntValue>(Varptr Self)

The problem was that it was constructing a temporary object to pass to the node member and then immediately destroying it. This is a problem for the IntrusiveList since it uses a pointer to Self.

There are ways to go through this problem but they seem very hacky and prone to error. Here are two ways I solved the crashing.

The first one was passing a IntrusiveList<T> pointer to the constructor and use it as a Self pointer.

Monkey

Method New(pSelf:IntrusiveList<T> Ptr, _pOwner:T Ptr = Null) pPrev = pSelf pNext = pSelf pHead = pSelf pOwner = _pOwner End

1 2 3 4 5 6

Method New(pSelf:IntrusiveList<T> Ptr, _pOwner:T Ptr = Null) pPrev = pSelf pNext = pSelf pHead = pSelf pOwner = _pOwner End

and I had to change my test to this:

Monkey

Struct IntValue Method New(_value:Int) value = _value ' Forced to pass a pointer to node for it to work node = New IntrusiveList<IntValue>(Varptr node, Varptr Self) End Field value:Int Field node:IntrusiveList<IntValue> End Function Main:Void() Local root:IntrusiveList<IntValue> Local a:IntValue = New IntValue(0) ' I am forced to init this after declaring root ' because I get undefined 'root' root = New IntrusiveList<IntValue>(Varptr root, Null) a.node.InsertTail(Varptr root) End

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

Struct IntValue Method New(_value:Int) value = _value ' Forced to pass a pointer to node for it to work node = New IntrusiveList<IntValue>(Varptr node, Varptr Self) End Field value:Int Field node:IntrusiveList<IntValue> End   Function Main:Void() Local root:IntrusiveList<IntValue> Local a:IntValue = New IntValue(0) ' I am forced to init this after declaring root ' because I get undefined 'root' root = New IntrusiveList<IntValue>(Varptr root, Null) a.node.InsertTail(Varptr root) End

The other one was adding an Init method that would take care of this:

Monkey

Struct IntrusiveList<T> Method New(_pOwner:T Ptr = Null) Init(_pOwner) End Method Init:Void(_pOwner:T Ptr = Null) pPrev = Varptr Self pNext = Varptr Self pHead = Varptr Self pOwner = _pOwner End ' ... Other methods... End

1 2 3 4 5 6 7 8 9 10 11 12 13

Struct IntrusiveList<T> Method New(_pOwner:T Ptr = Null) Init(_pOwner) End Method Init:Void(_pOwner:T Ptr = Null) pPrev = Varptr Self pNext = Varptr Self pHead = Varptr Self pOwner = _pOwner End     ' ... Other methods... End

And calling it like this in the IntValue constructor:

Monkey

Method New(_value:Int) value = _value node.Init(Varptr Self) End

1 2 3 4

Method New(_value:Int) value = _value node.Init(Varptr Self) End

Both of this solutions are error-prone in several ways.

What I suggest Is having a solution similar to intializer list. Maybe like this:

Monkey

Struct Foo Method New(x:Float = 0.0) value{x} End Field value:Float End

1 2 3 4 5 6

Struct Foo Method New(x:Float = 0.0) value{x} End Field value:Float End

The other issue I commented about was default constructors. This is something specific to Structs

For example if you don’t call explicitly the constructor on a struct it will call an empty generated constructor. Even If you define a constructor without any arguments it won’t be called since it’ll generate a code that forces it to go with the empty generated constructor. It’d be nice to have something like this:

Monkey

Local x:Foo(100.0)

1	Local x:Foo(100.0)

This way we avoid creating unnecessary temporary objects and calling the copy constructor.

I know this is probably low priority and some people probably don’t even care for stuff like this but I feel I would make the language more flexible and efficient.

Cheers,

Felipe

[Mark SiblyKeymaster]

Use classes, not structs, for reference types!

Structs are not designed to be used ‘by reference’. Yes, you can Varptr them, but as you’ve found, as soon as they are assigned to something, passed to a function or returned from a function (which is what they’re designed for) the old Ptr becomes invalid. The intended use for Varptr with structs is really for interfacing with c/c++.

Varptr Self is esp. dangerous, as the code has no way of knowing if ‘Self’ is temporary or not. Self could refer to a local, a temporary copy, etc that is just about to go out of scope, or it could refer to ‘safe’ heap memory, such as a class field, global or array element.

This is one of the primary difference between c++ and mx2. In c++, structs/classes are the same thing and can be used as either references types or value types depending on how variables are declared. But in mx2 (and c# and d), a struct is always a value type while a class is always a reference type. Not as flexible as c++, but IMO well worth the huge amount of simplification it provides.

[dawlaneParticipant]

@Mark: This is one of the things that needs to be explained in the language docs.

[FelipeParticipant]

Hi Mark,

Thanks for the reply. I understand but one of the reasons I wanted to use Structs instead of Class for IntrusiveList was to avoid heap allocation. At the end I would get fragmented resources which would defeat the whole purpose of creating an intrusive list.

Monkey

' IntValue layed out in memory if IntrusiveList is a Struct Class IntValue [ value : Int, node_pPrev : IntrusiveList node_pNext : IntrusiveList node_pHead : IntrusiveList node_pOwner : IntValue ] ' IntValue layed out in memory if IntrusiveList is a Class Class IntValue [ value : Int node : IntrusiveList -> Some random place in memory ]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

' IntValue layed out in memory if IntrusiveList is a Struct Class IntValue [ value : Int, node_pPrev : IntrusiveList node_pNext : IntrusiveList node_pHead : IntrusiveList node_pOwner : IntValue ]   ' IntValue layed out in memory if IntrusiveList is a Class Class IntValue [ value : Int node : IntrusiveList -> Some random place in memory ]

IntrusiveList as a Class would be a very slow structure.

Cheers,

Felipe.

[Author]

Posts