Code generation does not support recursive calls of the delete method. Do not create an object of a certain class inside the delete method for the same class. This usage might cause a recursive call of delete and result in an error message.

The generated code always calls the delete method, when an object goes out of scope. Code generation does not support explicit calls of the delete method.

Initialize all properties of MyClass that the delete method of MyClass uses either in the constructor or as the default property value. If delete tries to access a property that has not been initialized in one of these two ways, the code generator produces an error message.

Suppose a property prop1 of MyClass1 is itself an object (an instance of another class MyClass2). Initialize all properties of MyClass2 that the delete method of MyClass1 uses. Perform this initialization either in the constructor of MyClass2 or as the default property value. If delete tries to access a property of MyClass2 that has not been initialized in one of these two ways, the code generator produces an error message. For example, define the two classes MyClass1 and MyClass2:

classdef MyClass1 < handle
    properties
        prop1
    end
    methods
        function h = MyClass1(index)
            h.prop1 = index;
        end
        function delete(h)
            fprintf('h.prop1.prop2 is: %1.0f\n',h.prop1.prop2);
        end
    end
end

classdef MyClass2 < handle
    properties
        prop2
    end
end

Suppose you try to generate code for this function:

function MyFunction
obj2 = MyClass2;
obj1 = MyClass1(obj2); % Assign obj1.prop1 to the input (obj2)
end

The code generator produces an error message because you have not initialized the property obj2.prop2 that the delete method displays.

The order of destruction of several independent objects might be different in MATLAB than in the generated code.

The lifetime of objects in the generated code can be different from their lifetime in MATLAB. MATLAB calls the delete method when an object can no longer be reached from any live variable. The generated code calls the delete method when an object goes out of scope. In some situations, this difference causes delete to be called later on in the generated code than in MATLAB. For example, define the class:

classdef MyClass < handle
    methods
        function delete(h)
            global g
            % Destructor displays current value of global variable g
            fprintf('The global variable is: %1.0f\n',g);
        end
    end
end

Run the function:

function MyFunction
global g
g = 1;
obj = MyClass;
obj = MyClass;
% MATLAB destroys the first object here
g = 2;
% MATLAB destroys the second object here
% Generated code destroys both objects here
end

The first object can no longer be reached from any live variable after the second instance of obj = MyClass in MyFunction. MATLAB calls the delete method for the first object after the second instance of obj = MyClass in MyFunction and for the second object at the end of the function. The output is:

The global variable is: 1
The global variable is: 2

In the generated code, both delete method calls happen at the end of the function when the two objects go out of scope. Running MyFunction_mex results in a different output:

The global variable is: 2
The global variable is: 2

In MATLAB, persistent objects are automatically destroyed when they cannot be reached from any live variable. In the generated code, you have to call the terminate function explicitly to destroy the persistent objects.

The generated code does not destroy partially constructed objects. If a handle object is not fully constructed at run time, the generated code produces an error message but does not call the delete method for that object. For a System object™, if there is a run-time error in setupImpl, the generated code does not call releaseImpl for that object.

MATLAB does call the delete method to destroy a partially constructed object.