Main Content

Create and Initialize Object Arrays

You can create arrays of class-based objects with indexing behavior similar to built-in types like double or string. However, creating object arrays requires particular attention to how the objects are constructed.

Create an Object Array Using a Loop

Define the class SimpleValue, which has one property with an initial value and the default, no-argument constructor.

classdef SimpleValue
      prop1 = 0

Create an array of SimpleValue objects using a loop.

for k = 1:5
   objArray(k) = SimpleValue;

Reference and assign the property values of specific objects using array indexing. For example, assign the value of 5 to the prop1 property of objArray(1).

objArray(1).prop1 = 5;

Return the values of prop1 for all the objects and assign them to a vector.

p = [objArray.prop1]
p =

     5     0     0     0     0

For more information on accessing properties and methods of an object array, see Accessing Properties and Methods in Object Arrays.

Create an Object Array by Constructing the Last Element

In the SimpleValue example, the objects in objArray are created inside a loop using the default, no-argument constructor and initial property values. You can also create an array of SimpleValue objects by constructing the last element of the array.

For example, create a 2-by-2 array of SimpleValue objects.

a(2,2) = SimpleValue
a = 

  2×2 SimpleValue array with properties:


When you create an object array this way, MATLAB® takes one of two approaches to fill in the rest of the elements of the array, depending on whether the class is value or handle.

Value Class Arrays

After you construct the last element in an array of value class objects, MATLAB:

  • Calls the no-argument constructor once

  • Fills in the rest of the elements with copies of that instance

If you want to initialize property values using an input to the constructor, you must also have a no-argument option in the constructor.

For example, add a constructor to SimpleValue that accepts an input and assigns it that input to prop1.

classdef SimpleValue
      prop1 = 0
      function obj = SimpleValue(v)
         if nargin > 0
            obj.prop1 = v;

Create a 1-by-5 array by constructing b(5) with input argument 7.

b(5) = SimpleValue(7);

Return all of the prop1 values and assign them to a vector y. The object in b(5) has a prop1 value of 7. MATLAB calls the no-argument constructor once and copies that value to all the remaining elements in the array. Those elements have the initial prop1 value of 0.

y = [b.prop1]
y =

     0     0     0     0     7

If the SimpleValue constructor cannot handle no-argument calls, MATLAB errors when trying to populate b(1) through b(4).

Handle Class Arrays

After you construct the last element in an array of handle class objects, MATLAB:

  • Creates unique handles for each element of the array

  • Copies the property values from the last object in the array

  • Creates objects for the rest of the array using those copied values, without calling the constructor

Unlike the case for value classes, MATLAB does not call the constructor to populate the array, so all objects in that array start with the same property values. For example, define a handle class that generates random numbers for its property.

classdef InitHandleArray < handle
      function obj = InitHandleArray
         obj.RandNum = randi(100);

Create a new 1-by-5 array by constructing c(5), and verify the prop1 values. To create the array, MATLAB calls the constructor twice. The first time, MATLAB assigns a value to c(5).RandNum. The second time, it assigns the result of a second call to randi to create c(1). Finally, it copies this value of RandNum to the rest of the elements in c.

c(5) = InitHandleArray;
z = [c.RandNum]
z =

    91    91    91    91    82

Although MATLAB does not need a no-argument option in the constructor to create a handle class array, having a no-argument option is still the recommended practice for all class constructors.

Create an Object Array in the Constructor

You can also use the class constructor itself to create and return an object array. For example, the ObjectArray class creates an object array that is the same size as the 2-D input array F. The constructor then initializes the Value property of each object to the corresponding input array value.

classdef ObjectArray
      function obj = ObjectArray(F)
         if nargin ~= 0
            m = size(F,1);
            n = size(F,2);
            p(m,n) = obj;
            for i = 1:m
               for j = 1:n
                  p(i,j).Value = F(i,j);
            obj = p;

This pattern for the constructor works for both value and handle objects as long as the no-argument option is included.

Related Topics