Generate C++ Classes for MATLAB Classes

When you generate C++ code, the default behavior of the code generator is to produce C++ classes for the classes in your MATLAB^® code. These include all MATLAB classes such as value classes, handle classes, and system objects.

You can change the default behavior of the code generator and produce structures for MATLAB classes. To make this choice, do one of the following:

In a code configuration object, set TargetLang to 'C++' and CppPreserveClasses to false.
In the MATLAB Coder™ app, in the Generate step, set Language to C++. In the project build settings, on the Code Appearance tab, clear the Generate C++ classes from MATLAB classes check box.

The following examples illustrate certain rules that the code generator follows when mapping MATLAB classes to C++ classes.

Example: Generate Code for a Handle Class with Private and Public Members

Define a MATLAB handle class MyClass:

classdef MyClass < handle
    properties
        publicProp = 1;
    end
    properties(Access = private)
        privateProp
    end
    methods
        function obj = MyClass(value)
            obj.privateProp = value;
        end
        function publicMethod(obj,value)
            obj.privateMethod(value);
        end
        function res = calculateSomeValue(obj)
            res = obj.publicProp*obj.privateProp;
        end
    end
    methods (Access = private)
        function privateMethod(obj,value)
            obj.publicProp = obj.publicProp + value;
            obj.privateProp = obj.privateProp + obj.doubleThisValue(value);
        end
    end
    methods(Static)
        function res = doubleThisValue(val)
            res = 2 * val;
        end
    end
end

Define a MATLAB function foo that uses MyClass:

function out = foo(x,y)
obj = MyClass(x);
obj.publicMethod(y);
out = obj.calculateSomeValue;
end

Generate a static C++ library for foo. Specify the input argument to be a double scalar.

codegen -config:lib -lang:c++ foo -args {0,0} -report

Code generation successful: View report

Open the code generation report and inspect the generated code. The file MyClass.h contains the definition of the generated C++ class MyClass:

class MyClass
{
 public:
  MyClass *init(double value);
  void publicMethod(double value);
  static double doubleThisValue(double val);
  double calculateSomeValue() const;
  double publicProp;
 private:
  double privateProp;
};

This is the code generated for the function foo:

double foo(double x, double y)
{
  MyClass obj;
  obj.init(x);
  obj.publicMethod(y);
  return obj.calculateSomeValue();
}

This table illustrates some of the rules the code generator follows when generating C++ classes and corresponding snippets from the code generated for MyClass.

Rule	Code Snippet
The class constructor in MATLAB is mapped onto an `init` method. When an instance of the class is created, the generated code explicitly calls the `init` method.	The file `MyClass.cpp` contains the definition of `init`. MyClass MyClass::init(double value) { MyClass obj; obj = this; obj->publicProp = 1.0; obj->privateProp = value; return obj; }
In most cases, if a class member is set as private in MATLAB, it is also set as private in the generated C++ code. In certain cases, a private property in MATLAB might be changed to public in the generated code. For example, suppose that a public method `myMethod` that uses a private property `prop` of the object is called by an entry-point function in MATLAB. Also, assume that `myMethod` contains the `coder.inline('always')` directive that forces `myMethod` to be inlined in the generated code. So, in the generated code, the property `prop` must be visible from outside the object and changed to public. To limit the occurrence of this phenomenon, the code generator does not inline a public method unless the method contains the `coder.inline('always')` directive.	The definition of the generated C++ class `MyClass` is: class MyClass { public: MyClass *init(double value); void publicMethod(double value); static double doubleThisValue(double val); double calculateSomeValue() const; double publicProp; private: double privateProp; }; The visibility of all data and member functions is preserved between MATLAB and the generated code. The private method `privateMethod` does not appear in this definition. `privateMethod` is inlined in the definition of `publicMethod` (see in the file `MyClass.cpp`) : void MyClass::publicMethod(double value) { this->publicProp += value; this->privateProp += MyClass::doubleThisValue((value)); }
Static methods in MATLAB are mapped onto static C++ methods.	The generated code for the static method `doubleThisValue` has this signature: static double doubleThisValue(double val);
Methods that do not mutate the object are marked with the `const` qualifier in the generated code.	The public method `calculateSomeValue` does not mutate the object. The generated method has this signature: double calculateSomeValue() const;

Additional Usage Notes and Limitations

These are some additional usage notes and limitations for generating C++ classes from MATLAB classes:

The class prototype for MyClass is contained in the header file MyClass.h. The implementations of the methods of the class are contained in the file MyClass.cpp.
In the generated code, class hierarchies are flattened. For example, suppose that in your MATLAB code, class B inherits from class A. In the generated C++ code, classes B and A have no inheritance relationship between them. In the generated code, all properties and methods of class A are reproduced in the definition of class B.
When a MATLAB class uses different types for its properties, the code generator produces a separate C++ class for each type usage.
If a MATLAB class member has different GetAccess and SetAccess attributes, the corresponding member of the generated class has the more permissive of the two attributes. For example, if a property prop has the attributes (GetAccess = public, SetAccess = private), prop is defined to be public in the generated code.
While attempting to generate standalone code that contains C++ classes for MATLAB classes, you might get a warning message if both of these conditions are true:
- You choose to generate reentrant code by enabling the MultiInstanceCode parameter in a code configuration object, or by enabling the Generate re-entrant code parameter in the MATLAB Coder app.
- The destructor of a class in your MATLAB code has a persistent variable or calls another function that declares and uses a persistent variable.
In such situations, to generate code that contains C++ classes for MATLAB classes, disable the MultiInstanceCode or the Generate re-entrant code parameter.

Documentation