【Advanced】Combining C++ with MATLAB (Mutual Invocation) Methods

# [Advanced篇] Combining C++ with MATLAB (Mutual Invocation) Methods

## 2.1 Creation and Initialization of MATLAB Engine

### 2.1.1 Creation of MATLAB Engine

Creating a MATLAB engine in C++ requires the use of the `engOpen` function. The prototype of this function is as follows:

engOpen(const char* version) -> mxArray*

Here, the `version` parameter specifies the version of the MATLAB engine to be created. If `version` is set to `NULL`, the latest version of the MATLAB engine will be created.

### 2.1.2 Initialization of MATLAB Engine

After creating a MATLAB engine, it needs to be initialized using the `engInitialize` function. The prototype of this function is as follows:

engInitialize(mxArray* engine) -> int

Here, the `engine` parameter is the MATLAB engine created using the `engOpen` function.

## 2. Invoking MATLAB from C++

### 2.1 Creation and Initialization of MATLAB Engine

#### 2.1.1 Creation of MATLAB Engine

// Create MATLAB Engine
MATLAB::Engine *ep = engOpen(NULL);
if (ep == NULL) {
   std::cerr << "Error: Unable to create MATLAB engine" << std::endl;
   exit(1);
}

- The `engOpen` function creates a MATLAB engine and returns a pointer to it.
- If the creation fails, `ep` will be `NULL`, and the program will exit with an error message.

#### 2.1.2 Initialization of MATLAB Engine

// Initialize MATLAB Engine
if (ep->Init()) {
   std::cerr << "Error: Unable to initialize MATLAB engine" << std::endl;
   exit(1);
}

- The `Init` function initializes the MATLAB engine, loads the MATLAB path, and compiles MATLAB functions.
- If the initialization fails, the program will exit with an error message.

### 2.2 Data Exchange Between C++ and MATLAB

#### 2.2.1 Passing Data from C++ to MATLAB

// Create MATLAB variable
mxArray *mx = mxCreateDoubleScalar(10.0);

// Pass MATLAB variable to MATLAB Engine
if (ep->PutVariable("x", mx)) {
   std::cerr << "Error: Unable to pass variable to MATLAB" << std::endl;
   exit(1);
}

- The `mxCreateDoubleScalar` function creates a MATLAB double scalar variable.
- The `PutVariable` function passes the MATLAB variable to the MATLAB engine.
- If the passing fails, the program will exit with an error message.

#### 2.2.2 Returning Data from MATLAB to C++

// Get MATLAB variable
mxArray *mx = ep->GetVariable("y");

// Convert MATLAB variable to C++ double type
double y = mxGetScalar(mx);

- The `GetVariable` function gets the MATLAB variable from the MATLAB engine.
- The `mxGetScalar` function converts the MATLAB variable to C++ double type.

### 2.3 Invoking MATLAB Functions and Scripts from C++

#### 2.3.1 Invoking MATLAB Functions

// Invoke MATLAB function
mxArray *mx = ep->Feval("disp", 1, mxCreateString("Hello, MATLAB!"));

- The `Feval` function invokes a MATLAB function.
- The first parameter is the function name, the second is the number of input parameters, and the third is the array of input parameters.
- The `mxCreateString` function creates a MATLAB string variable.

#### 2.3.2 Invoking MATLAB Scripts

// Invoke MATLAB script
if (ep->EvalFile("myscript.m")) {
   std::cerr << "Error: Unable to evaluate MATLAB script" << std::endl;
   exit(1);
}

- The `EvalFile` function invokes a MATLAB script.
- If the invocation fails, the program will exit with an error message.

## 3. MATLAB Invoking C++

### 3.1 Creating a C++ Dynamic Link Library (DLL)

#### 3.1.1 Writing a C++ DLL

**Writing DLL Source Code**

Write a DLL in C++ containing the functions to be called from MATLAB. For example, the following code defines a function called `addNumbers` that adds two numbers:

// addNumbers.cpp
#include <iostream>

extern "C" __declspec(dllexport) int addNumbers(int a, int b) {
   std::cout << "C++ DLL: Adding numbers..." << std::endl;
   return a + b;
}

**Parameter Description:**

- `a`: The first number
- `b`: The second number

**Return:**

- The sum of the two numbers

#### 3.1.2 Compiling and Linking a C++ DLL

**Compiling the DLL**

Use the following command to compile the DLL source code:

cl /LD /Fe addNumbers.dll addNumbers.cpp

**Linking the DLL**

Use the following command to link the DLL to the MATLAB executable:

link /DLL /OUT:addNumbers.dll addNumbers.obj

## 3.2 MATLAB Loading and Invoking a C++ DLL

#### 3.2.1 Loading a C++ DLL

**Using the `loadlibrary` Function**

Use the `loadlibrary` function to load a C++ DLL:

dllHandle = loadlibrary('addNumbers.dll');

**Parameter Description:**

- `'addNumbers.dll'`: The name of the DLL

**Return:**

- `dllHandle`: A handle to the DLL

#### 3.2.2 Invoking a Function in a C++ DLL

**Using the `calllib` Function**

Use the `calllib` function to invoke a function in a C++ DLL:

result = calllib('addNumbers', 'addNumbers', 5, 10);

**Parameter Description:**

- `'addNumbers'`: The name of the DLL
- `'addNumbers'`: The name of the function to be called
- `5`: The first number
- `10`: The second number

**Return:**

- `result`: The return value of the function (the sum of the two numbers)

**Code Logic Analysis:**

1. The `loadlibrary` function loads the DLL and returns a handle.
2. The `calllib` function uses the handle to call the `addNumbers` function in the DLL.
3. The function returns the sum of the two numbers and stores it in the `result` variable.

**Table: Comparison of `loadlibrary` and `calllib` Functions**

| Function | Purpose | Parameters | Return |
|---|---|---|---|
| `loadlibrary` | Load DLL | DLL name | DLL handle |
| `calllib` | Invoke DLL function | DLL handle, function name, parameters | Function return value |

**mermaid Flow