Linked lists

Trees

Graphs

addlistener

eq

findobj

findprop

The subclass has a property with the same name as a property of the superclass.

The subclass derives from multiple superclasses that use the same name for a property.

If the property does not have an explicit initial value, the code generator assumes that it is undefined at the beginning of the constructor. The code generator does not assign an empty matrix as the default.

If the property does not have an initial value and the code generator cannot determine that the property is assigned prior to first use, the software generates a compilation error.

For System objects, if a nontunable property is a structure, you must completely assign the structure. You cannot do partial assignment using subscripting.

For example, for a nontunable property, you can use the following assignment:

mySystemObject.nonTunableProperty=struct('fieldA','a','fieldB','b');

You cannot use the following partial assignments:

mySystemObject.nonTunableProperty.fieldA = 'a';
mySystemObject.nonTunableProperty.fieldB = 'b';

coder.varsize is not supported for class properties.

If the initial value of a property is an object, then the property must be constant. To make a property constant, declare the Constant attribute in the property block. For example:

classdef MyClass 
    properties (Constant) 
        p1 = MyClass2; 
    end 
end 

Code generation does not support a constant property that is assigned to an object that contains a System object™.

MATLAB computes class initial values at class loading time before code generation. If you use persistent variables in MATLAB class property initialization, the value of the persistent variable computed when the class loads belongs to MATLAB; it is not the value used at code generation time. If you use coder.target in MATLAB class property initialization, coder.target('MATLAB') returns true (1).

Code generation supports upper-bounded and unbounded variable-size properties for both value and handle classes.

To generate unbounded variable-size class properties, enable dynamic memory allocation.

To make a variable-size class property, make two sequential assignments of a class property, one to a scalar and the next to an array.

classdef varSizeProp1 < handle
    properties
        prop
        varProp
    end
end

function extFunc(n)
    obj = varSizeProp1;    
    % Assign a scalar value to the property.
    obj.prop = 1;
    obj.varProp = 1;
    % Assign an array to the same property to make it variable-size.
    obj.prop = 1:98;    
    obj.varProp = 1:n;
end

In the preceding code, the first assignment to prop and varProp is scalar, and their second assignment is to an array with the same base type. The size of prop has an upper bound of 98, making it an upper-bounded, variable-size property.

If n is unknown at compile time, obj.varProp is an unbounded variable-size property. If it is known, it is an upper-bounded, variable-size class property.

If the class property is initialized with a variable-size array, the property is variable-size.

classdef varSizeProp2 
    properties
        prop
    end
    methods
        function obj = varSizeProp2(inVar)
            % Assign incoming value to local variable
            locVar = inVar;
            
            % Declare the local variable to be a variable-size column             
            % vector with no size limit
            coder.varsize('locVar',[inf 1],[1 0]);
            
            % Assign value
            obj.prop = locVar;
         end
    end
end

In the preceding code, inVar is passed to the class constructor and stored in locVar. locVar is modified to be variable-size by coder.varsize and assigned to the class property obj.prop, which makes the property variable-size.

obj is an object of myClass1.

myClass1 has a constant property p1 that is an object of myClass2.

myClass2 has a property p2.