MATLAB: Do I receive an error when I reference a property of a handle class that contains another property of the same class

MATLAB

Suppose I have two handle classes, 'super' and 'sub', defined as follows.

'super' is a handle class has two properties. Of these,

 * 'subObject' holds an instance of 'sub' and has attributes (Access = public).
 * 'CellArray'  is a cell array that points to the other property 'subObject' in its first element. This property has attributes (SetAccess = private, GetAccess = public).
classdef super < handle
    properties (Access = public)    
      subObject       
    end
    properties (SetAccess = private, GetAccess = public)
      CellArray       
    end
    methods
      function obj = super()
        obj.subObject=sub();
        obj.CellArray{1}=obj.subObject;       
      end                   
    end 
end

'sub' is a handle class that has one property:

 * 'theString' holds a character array.
classdef sub < handle
    properties (Access = public)    
      theString
    end
    methods
      function obj = sub()      
        obj.theString = 'MATLAB';                              
      end                           
    end 
end

Finally, when I get inconsistent results with the following syntax for try to modify the value of 'CellArray' in a 'super' object:

For instance, the following syntax throws an error:

clear all;
clear classes;
o = super();
o.CellArray{1}.theString % To check the initial property;
o.CellArray{1}.theString = 'something else'

 ??? Setting the 'CellArray' property of the
 'super' class is not allowed.
 Error in ==>
 o.CellArray{1}.theString = 'something else'

However, when I try to do the same with the following syntax, breaking up the single line into a multipart snippet, I receive no error, but the value still changes to 'something else':

clear classes;
o = super();
o2 = o.CellArray{1};
o2.theString
o2.theString = 'something else';

Best Answer

This is not a bug in MATLAB, but expected behavior. If this is not desired behavior in your application, consider defining the classes as value classes, rather than handles classes.

In both cases, the underlying value 'theString' is changed and this is to be expected even though it happens through the 'SetAccess=private' attributed property 'CellArray'. This is because the contract that the user has with the super class states that the property 'theString' can be modifiable per its 'SetAccess=public' attribute, regardless of whether it was called through CellArray or not. This is the inherent nature of handle classes and this is intended to be the case.

In the first calling syntax,

o.CellArray{1}.theString = 'something else'

the error is thrown as a courtesy to inform the user that CellArray{1} should not be modified directly.

The code parser in MATLAB still considers these lines as separate executions, similar to the second calling syntax, even when it is inlined as one expression. Since the right-hand side of the expression (....theString = 'something else') is executed first, the value of the 'theString' property gets modified even before the parser realizes that it is referenced through another 'SetAccess=private' property.

Related Solutions

MATLAB: Passing on superclass property values to subclass

I think what Adam said here is the key:

but it knows it is creating this as part of creating the subclass

In other words, the 'obj' output of the myclass() constructor is not an ordinary output variable. Not only is it pre-initialized when the myclass workspace is entered, but the pre-initialization type also depends on how myclass() was invoked. If it was invoked using a subclass object, as in subclassObj@myclass() then obj is pre-intialized to the subclass type. This is confirmed by the following,

     classdef myclass 
         methods 
             function obj=myclass
                 disp ' '
                      disp(['obj is a ' class(obj) ' object'])
                 disp ' '
             end
         end
     end
    classdef mysubclass < myclass
        methods 
             function obj=mysubclass
                    obj=obj@myclass;
             end
         end
    end

which gives the behavior:

    >> myclass;
    obj is a myclass object
    >> mysubclass;
    obj is a mysubclass object

And therefore, assigning obj a superclass object, even in the superclass constructor, can force it to be the wrong type.

MATLAB: How are objects converted from one type to another when collected together in an array in MATLAB 7.6 (R2008a)

When MATLAB sees a subscripted assignment to an existing variable, MATLAB checks the class of the right-hand-side against the class of the left-hand-side (LHS) variable. If different, it attempts to convert the right-hand-side (RHS) variable to the type of the LHS class.

To achieve this, MATLAB first looks for a method of the RHS class that has the same name as the LHS class. This is a converter method from one class to another and similar in some ways to a cast operator in C++.

If there is no specific converter, then MATLAB calls the LHS constructor and passes the RHS variable as input. This is irrespective of the class relationship between the LHS and RHS variable.

In the above example, the LHS class is SuperClass and the RHS class is SubClass. When the following line is executed,

vec(2) = subobj

since SubClass does not have a method SuperClass, MATLAB calls the SuperClass constructor with subobj as the single input, resulting in an error.

To facilitate the conversion from SubClass to SuperClass, you can create a method named SuperClass in class SubClass with the following signature

function obj = SuperClass(subobj)
      obj = SuperClass(subobj.prop1, subobj.prop2);
end

Alternatively, you can modify the constructor of SuperClass to accommodate single inputs of type SuperClass. One implementation of the constructor could be,

function obj = SuperClass(prop1, prop2)
      if isa(prop1,'SuperClass')
          obj.prop1 = prop1.prop1;
          obj.prop2 = prop1.prop2;
      else
          obj.prop1 = prop1;
          obj.prop2 = prop2;
      end
end

One drawback of the previous methods is that a copy of the object is created.

As an alternative, you can preserve the original class of the objects and still aggregate the objects by using a cell array as follows:

vec{1} = supobj;
vec{2} = subobj;

Best Answer

Related Solutions

MATLAB: Passing on superclass property values to subclass

MATLAB: How are objects converted from one type to another when collected together in an array in MATLAB 7.6 (R2008a)

Related Question