Initializing arrays of objects with distinct handle properties

When I initialize an array of handle objects (or matlab.mixin.Copyable) with handle properties, my properties are all handles to the same objects, except for the last element of the array. The last element makes sense based on the description of how matlab instantiates objects. The documentation here ( https://www.mathworks.com/help/matlab/matlab_oop/initialize-property-values.html ) indicates that constructors should call the constructors of any handle properties to ensure a fresh object. I do not observe this behavior.

For the classes below, Junk1 has two properties, each of type Junk2. My expectation is that prop1 would be a fresh handle because it is initialized in the Junk1 constructor, whereas prop2 has a default which is copied for all instances of Junk1 in the 'x' array except for the last element. It seems that x(1).prop1 == x(2).prop1. How can I initialize arrays of handle objects, which have handle properties that are distinct?

>> x(3,1)= Junk1();

>> x(1).prop1

ans =

Junk2 with properties:

value: -1.7115

>> x(2).prop1

ans =

Junk2 with properties:

value: -1.7115

>> x(3).prop1

ans =

Junk2 with properties:

value: 1.3703

>> x(1).prop1 == x(2).prop1

ans =

logical

1

>>

classdef Junk1 < handle
    properties(GetAccess=public, SetAccess=public)
        prop1 (1,1) Junk2
        prop2 (1,1) Junk2 = Junk2()
    end
    methods(Access=public)
        function obj = Junk1()
            obj.prop1 = Junk2();
        end
    end
end 



classdef Junk2 < handle
    properties(GetAccess=public, SetAccess=public)
        value (1,1) double 
    end
    methods(Access=public)
        function obj = Junk2(a)
            if (nargin == 1)
                obj.value = a;
            else
                obj.value = randn;
            end
        end
    end
end 

Answer 1

[Matt J]

You can also rewrite the Junk1() constructor to generate array-valued output:

classdef Junk1 < handle
    properties(GetAccess=public, SetAccess=public)
        prop1 (1,1) Junk2
        prop2 (1,1) Junk2 
    end
    methods(Access=public)
        function obj = Junk1(varargin)

            if ~nargin, return; end
 
            siz=[varargin{:}];
            obj(prod(siz))=Junk1();
            obj=reshape(obj,siz);

            for i=1:numel(obj)
                obj(i).prop1=Junk2();
            end

        end
    end
end 

>> x=Junk1(3,1), x.prop1

x =

3×1 Junk1 array with properties:

prop1

prop2

ans =

Junk2 with properties:

value: 0.1339

ans =

Junk2 with properties:

value: 0.6561

ans =

Junk2 with properties:

value: 0.6697

[SA]

Your example of a double array makes sense and is consistent with object array creation. The distinction is that builtin types are value classes and not handle classes. The matlab documentation is accurate in that calling property constructors in the main constructor does result in distinct object handles for repeated calls, just not for array creation. In addition to the three methods you supplied (arrayfun, rewrite constructor, static method) a simple but transparent fourth option would be to preallocate and then assign:

x(3,1) = Junk1();
for idx = 1 : 3
    x(idx)= Junk1();
end
x(1).prop1 == x(2).prop1 
ans =
  logical
   0

This is similar to your rewrite of the constructor, but performed outside the class. Thanks for exploring the options.

[Matt J]

The matlab documentation is accurate in that calling property constructors in the main constructor does result in distinct object handles for repeated calls, just not for array creation.

Yes... but I think it's important to understand that that's only because there are no repeated constructor calls when you create an array of default elements. A default element is created by calling the constructor once, and that object is then copied throughout the array where needed. This is true for all object types, both handle and value, and for both user-defined and built-in objects. The following code modification shows that the constructor is called twice, even though 10 elements are created. You can verify that this happens for value objects as well.

classdef Junk1 < handle
    properties(GetAccess=public, SetAccess=public)
        prop1 (1,1) Junk2
    end

    methods 
        function  obj=Junk1()

           disp 'Constructing'

            obj.prop1=Junk2();

        end
    end

    methods(Static)

        function objs = array(varargin)

            objs=arrayfun(@(z)Junk1(), ones(varargin{:})  );

        end
    end
end 

>> x(10)=Junk1

Constructing

Constructing

x =

10×1 Junk1 array with properties:

prop1

Answer 2

[Matt J]

One way:

x=arrayfun(@(z)Junk1,ones(3,1))

x.prop1

x =

3×1 Junk1 array with properties:

prop1

prop2

ans =

Junk2 with properties:

value: -0.7108

ans =

Junk2 with properties:

value: 0.3310

ans =

Junk2 with properties:

value: 0.3542

[SA]

This does indeed produce array elements with unique properties. Is there no other way to initialize arrays of handle classes? Rewriting the constructor below is an option, but many of my classes have either an N argument signature for providing content or a 0 argument signature for array initialization. I was hoping the solution would fall in line with initializing arrays of other built-in types such as structures, datetimes, durations, doubles, etc. It's troubling the matlab documentation doesn't seem to match the behavior. My concern is that downstream users may not know to use arrayfun().

[Matt J]

It's troubling the matlab documentation doesn't seem to match the behavior.

Doesn't it? From the documentation:

When you use a handle class constructor to create a default property value, MATLAB calls the constructor only when the class is first used, and then uses the same object handle as the default for the property in all instances. Because all of the object handles reference the same object, any changes you make to the handle object in one instance are reflected in the handle object in all instances. To initialize a property value with a new instance of a handle object each time you instantiate your class, assign the property value in the constructor.

[SA]

It's the last line that seems errant. By explicitly calling the constructor of any handle class properties in the main class constructor, I expected all the elements to get distinct properties. The main array gets distinct instances of Junk1, which is great, but only half the battle. If I have to explicitly assign every handle property (and sub property) of a class, then handle classes don't hold much use for me. Mutating one mutates them all.

If instances are created separately, e.g.,

x = Junk1();

y = Junk1();

Then,

x.prop1 == y.prop1 is false, but when an array is created, matlab gets lazy and turns into a used car salesman, offering you a handle to whatever it has sitting on the lot.

It seems to initialize arrays the best option is to rewrite the constructor with a signature that allows specifying the size as you demonstrated below. I did not realize that a handle constructor could return an array of objects.

[Matt J]

By explicitly calling the constructor of any handle class properties in the main class constructor, I expected all the elements to get distinct properties.

If a separate constructor call were made to fill every unspecified array element, that would be very slow. That's not how any of the Matlab classes work, even the built-in ones. Consider the example below. Does it surprise you that the first 4 elements of x are copies of the same element (0) ?

x(5,1)=double(1)

x = 5×1

0 0 0 0 1

[Matt J]

Rewriting the constructor below is an option, but many of my classes have either an N argument signature for providing content or a 0 argument signature for array initialization.

If you don't want to redesign your constructor syntax for the purpose of creating object arrays, you can always add a Static method for this purpose, e.g.,

classdef Junk1 < handle
    properties(GetAccess=public, SetAccess=public)
        prop1 (1,1) Junk2
    end

    methods 
        function  obj=Junk1()

            obj.prop1=Junk2();

        end
    end

    methods(Static)

        function objs = array(varargin)

            objs=arrayfun(@(z)Junk1(), ones(varargin{:})  );

        end
    end
end 

>> x=Junk1.array(3,1), x.prop1

x =

3×1 Junk1 array with properties:

prop1

ans =

Junk2 with properties:

value: -0.7601

ans =

Junk2 with properties:

value: 1.2245

ans =

Junk2 with properties:

value: 1.4168