Matlab有很多封装好的函数，可以直接使用，但是如果不使用并行计算方式的话其运行速度还是比较慢的。而c++作为一种静态编程语言，其运行速度非常快，但缺点是没有丰富的第三方库，而且有些C++第三方库配置起来也非常的麻烦。所以我们可以想到把C++和matlab进行混合编程。下面是我的一些配置过程。（后面发现有更简单的设置）

配置条件：win11，clion c++语言，工具链msvc，matlab 2024b

在clion里新建一个项目，cmakelists.txt设置如下：

cmake_minimum_required(VERSION 3.20)
project(matlabcpp)

set(CMAKE_CXX_STANDARD 20)

# 设置 MATLAB 根目录
set(MATLAB_ROOT "I:/software/matlab2024b")

# 检查 MATLAB 路径是否存在
if(NOT EXISTS ${MATLAB_ROOT})
    message(FATAL_ERROR "MATLAB路径不存在: ${MATLAB_ROOT}")
endif()

message(STATUS "使用MATLAB路径: ${MATLAB_ROOT}")

# 包含 MATLAB 头文件
include_directories(${MATLAB_ROOT}/extern/include)

# 设置 MATLAB 库路径
link_directories(${MATLAB_ROOT}/extern/lib/win64/microsoft)

# MSVC 编译器选项
if(MSVC)
    add_compile_options(/EHsc)
    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
endif()

# 创建可执行文件
add_executable(MatlabItest main.cpp)

# 链接 MATLAB 库
target_link_libraries(MatlabItest PRIVATE
        libeng.lib
        libmx.lib
        libmat.lib
        libmex.lib
)

# 复制必要的 DLL
set(MATLAB_DLLS
        "${MATLAB_ROOT}/bin/win64/libeng.dll"
        "${MATLAB_ROOT}/bin/win64/libmx.dll"
        "${MATLAB_ROOT}/bin/win64/libmat.dll"
        "${MATLAB_ROOT}/bin/win64/libmex.dll"
        "${MATLAB_ROOT}/bin/win64/mclmcr.dll"
        "${MATLAB_ROOT}/bin/win64/mcr.dll"
        "${MATLAB_ROOT}/bin/win64/libmwmcrr.dll"
        "${MATLAB_ROOT}/bin/win64/libmwservices.dll"
        "${MATLAB_ROOT}/bin/win64/libut.dll"
        "${MATLAB_ROOT}/bin/win64/m_dispatcher.dll"
        "${MATLAB_ROOT}/bin/win64/m_interpreter.dll"
        "${MATLAB_ROOT}/bin/win64/libmwi18n.dll"
)

foreach(dll_path ${MATLAB_DLLS})
    if(EXISTS ${dll_path})
        add_custom_command(TARGET MatlabItest POST_BUILD
                COMMAND ${CMAKE_COMMAND} -E copy_if_different
                ${dll_path}
                $<TARGET_FILE_DIR:MatlabItest>
        )
        message(STATUS "配置复制: ${dll_path}")
    else()
        message(WARNING "文件不存在，跳过: ${dll_path}")
    endif()
endforeach()

message(STATUS "MATLAB配置完成")

测试代码1：简单测试

#include <iostream>
#include <cstdlib>
#include <windows.h>
#include "engine.h"

int main() {
    std::cout << "=== C++ 调用 MATLAB 简单测试 ===" << std::endl;
    
    // 设置 DLL 搜索路径
    SetDllDirectoryA("I:\\software\\matlab2024b\\bin\\win64");
    
    std::cout << "1. 启动 MATLAB 引擎..." << std::endl;
    
    // 启动 MATLAB 引擎
    Engine* ep = engOpen(NULL);
    if (!ep) {
        std::cerr << "错误: 无法启动 MATLAB 引擎" << std::endl;
        return EXIT_FAILURE;
    }
    
    std::cout << "✓ MATLAB 引擎启动成功!" << std::endl;
    
    // 2. 基本命令测试
    std::cout << "2. 执行基本 MATLAB 命令..." << std::endl;
    engEvalString(ep, "disp('=== C++/MATLAB 连接成功 ===')");
    engEvalString(ep, "v = version; fprintf('MATLAB版本: %s\\n', v)");
    
    // 3. 简单计算测试
    std::cout << "3. 数学计算测试..." << std::endl;
    engEvalString(ep, "a = 25; b = 7;");
    engEvalString(ep, "c = a + b; d = a * b; e = a / b;");
    engEvalString(ep, "fprintf('计算: %d + %d = %d\\n', a, b, c)");
    engEvalString(ep, "fprintf('计算: %d * %d = %d\\n', a, b, d)");
    engEvalString(ep, "fprintf('计算: %d / %d = %.2f\\n', a, b, e)");
    
    // 4. 数据传递测试
    std::cout << "4. 数据传递测试..." << std::endl;
    
    // 创建一维数组
    mxArray* array1d = mxCreateDoubleMatrix(1, 5, mxREAL);
    double* data1d = mxGetPr(array1d);
    for (int i = 0; i < 5; i++) {
        data1d[i] = (i + 1) * 10.0;
    }
    
    // 发送到 MATLAB
    engPutVariable(ep, "cpp_array", array1d);
    engEvalString(ep, "disp('来自C++的一维数组:'); disp(cpp_array)");
    
    // 在 MATLAB 中处理数据
    engEvalString(ep, "squared = cpp_array .^ 2;");
    engEvalString(ep, "disp('平方结果:'); disp(squared)");
    
    // 5. 获取 MATLAB 计算结果
    std::cout << "5. 获取 MATLAB 计算结果..." << std::endl;
    mxArray* result = engGetVariable(ep, "squared");
    if (result) {
        double* resultData = mxGetPr(result);
        int numElements = mxGetNumberOfElements(result);
        
        std::cout << "C++ 接收到的平方结果: [";
        for (int i = 0; i < numElements; i++) {
            std::cout << resultData[i];
            if (i < numElements - 1) std::cout << ", ";
        }
        std::cout << "]" << std::endl;
        
        mxDestroyArray(result);
    }
    
    // 6. 内置函数测试
    std::cout << "6. MATLAB 内置函数测试..." << std::endl;
    engEvalString(ep, "x = 0:0.5:10;");
    engEvalString(ep, "y = sin(x) + 0.1*cos(3*x);");
    engEvalString(ep, "max_val = max(y); min_val = min(y); mean_val = mean(y);");
    engEvalString(ep, "fprintf('sin(x)+0.1*cos(3x) 统计:\\n');");
    engEvalString(ep, "fprintf('  最大值: %.4f\\n', max_val);");
    engEvalString(ep, "fprintf('  最小值: %.4f\\n', min_val);");
    engEvalString(ep, "fprintf('  平均值: %.4f\\n', mean_val);");
    
    std::cout << std::endl;
    std::cout << "==========================================" << std::endl;
    std::cout << "🎉 简单测试完成！" << std::endl;
    std::cout << "所有基础功能正常工作" << std::endl;
    std::cout << "按 Enter 键关闭 MATLAB 引擎..." << std::endl;
    std::cout << "==========================================" << std::endl;
    std::cin.get();
    
    // 清理资源
    mxDestroyArray(array1d);
    engClose(ep);
    
    std::cout << "MATLAB 引擎已关闭" << std::endl;
    return EXIT_SUCCESS;
}

这里会出现报错：

Process finished with exit code -1073741515 (0xC0000135)

然后在clion最上面的 Run → Edit Configurations 设置参数：找到Environment variables，添加

• Name: PATH

• Value: I:\software\matlab2024b\bin\win64;%PATH%     （中间那个是我matlab的绝对路径）

ok，应用确定。然后就可以直接使用c++调用matlab来求解问题了。

运行结果如下：

测试代码2：画图

#include <iostream>
#include <cstdlib>
#include <vector>
#include <cmath>
#include <windows.h>
#include "engine.h"

// 工具函数：将 C++ vector 转换为 MATLAB 数组
mxArray* vectorToMatlab(const std::vector<double>& vec) {
    mxArray* arr = mxCreateDoubleMatrix(1, vec.size(), mxREAL);
    double* data = mxGetPr(arr);
    for (size_t i = 0; i < vec.size(); i++) {
        data[i] = vec[i];
    }
    return arr;
}

// 工具函数：将 C++ 二维 vector 转换为 MATLAB 矩阵
mxArray* matrixToMatlab(const std::vector<std::vector<double>>& matrix) {
    if (matrix.empty()) return nullptr;
    
    size_t rows = matrix.size();
    size_t cols = matrix[0].size();
    
    mxArray* arr = mxCreateDoubleMatrix(rows, cols, mxREAL);
    double* data = mxGetPr(arr);
    
    for (size_t i = 0; i < rows; i++) {
        for (size_t j = 0; j < cols; j++) {
            data[i + j * rows] = matrix[i][j];
        }
    }
    return arr;
}

// 工具函数：从 MATLAB 获取数组并转换为 C++ vector
std::vector<double> matlabToVector(mxArray* arr) {
    if (!mxIsDouble(arr)) {
        throw std::runtime_error("数组不是 double 类型");
    }
    
    size_t numElements = mxGetNumberOfElements(arr);
    double* data = mxGetPr(arr);
    
    return std::vector<double>(data, data + numElements);
}

// 工具函数：显示 MATLAB 数组信息
void displayArrayInfo(const std::string& name, mxArray* arr) {
    std::cout << "数组 '" << name << "' 信息:" << std::endl;
    std::cout << "  维度: " << mxGetNumberOfDimensions(arr) << "D" << std::endl;
    
    const size_t* dims = mxGetDimensions(arr);
    std::cout << "  大小: [";
    for (int i = 0; i < mxGetNumberOfDimensions(arr); i++) {
        std::cout << dims[i];
        if (i < mxGetNumberOfDimensions(arr) - 1) std::cout << " x ";
    }
    std::cout << "]" << std::endl;
    std::cout << "  元素数量: " << mxGetNumberOfElements(arr) << std::endl;
    std::cout << "  数据类型: " << (mxIsDouble(arr) ? "double" : "其他") << std::endl;
}

int main() {
    std::cout << "=== C++ 调用 MATLAB 高级测试 ===" << std::endl;
    
    try {
        // 设置 DLL 搜索路径
        SetDllDirectoryA("I:\\software\\matlab2024b\\bin\\win64");
        
        std::cout << "1. 启动 MATLAB 引擎..." << std::endl;
        
        // 启动 MATLAB 引擎
        Engine* ep = engOpen(NULL);
        if (!ep) {
            throw std::runtime_error("无法启动 MATLAB 引擎");
        }
        
        std::cout << "✓ MATLAB 引擎启动成功!" << std::endl;
        
        // ==================== 测试1: 复杂数据结构 ====================
        std::cout << "\n2. 复杂数据结构测试..." << std::endl;
        
        // 2.1 创建复杂矩阵
        std::vector<std::vector<double>> complexMatrix = {
            {1.5, 2.5, 3.5, 4.5},
            {5.5, 6.5, 7.5, 8.5},
            {9.5, 10.5, 11.5, 12.5}
        };
        
        mxArray* matlabMatrix = matrixToMatlab(complexMatrix);
        engPutVariable(ep, "complex_matrix", matlabMatrix);
        engEvalString(ep, "disp('3x4 复杂矩阵:'); disp(complex_matrix)");
        
        // 2.2 矩阵运算
        engEvalString(ep, "matrix_transpose = complex_matrix';");
        engEvalString(ep, "disp('矩阵转置:'); disp(matrix_transpose)");
        
        engEvalString(ep, "matrix_sum = sum(complex_matrix, 1);");
        engEvalString(ep, "disp('列求和:'); disp(matrix_sum)");
        
        // ==================== 测试2: 字符串和字符数组 ====================
        std::cout << "\n3. 字符串处理测试..." << std::endl;
        
        // 3.1 创建字符串
        mxArray* cppString = mxCreateString("Hello from C++ Advanced Test!");
        engPutVariable(ep, "cpp_string", cppString);
        engEvalString(ep, "disp('C++ 字符串:'); disp(cpp_string)");
        
        // 3.2 字符串操作
        engEvalString(ep, "upper_string = upper(cpp_string);");
        engEvalString(ep, "disp('大写转换:'); disp(upper_string)");
        
        engEvalString(ep, "string_length = length(cpp_string);");
        engEvalString(ep, "fprintf('字符串长度: %d\\n', string_length)");
        
        // ==================== 测试3: 复杂数学运算 ====================
        std::cout << "\n4. 复杂数学运算测试..." << std::endl;
        
        // 4.1 线性代数
        std::vector<std::vector<double>> squareMatrix = {
            {4, 12, -16},
            {12, 37, -43},
            {-16, -43, 98}
        };
        
        mxArray* matlabSquareMatrix = matrixToMatlab(squareMatrix);
        engPutVariable(ep, "square_matrix", matlabSquareMatrix);
        
        engEvalString(ep, "disp('方阵:'); disp(square_matrix)");
        engEvalString(ep, "matrix_det = det(square_matrix);");
        engEvalString(ep, "fprintf('行列式: %.4f\\n', matrix_det)");
        
        engEvalString(ep, "matrix_inv = inv(square_matrix);");
        engEvalString(ep, "disp('逆矩阵:'); disp(matrix_inv)");
        
        engEvalString(ep, "identity_check = square_matrix * matrix_inv;");
        engEvalString(ep, "disp('验证逆矩阵 (应接近单位矩阵):'); disp(identity_check)");
        
        // 4.2 特征值和特征向量
        engEvalString(ep, "[eigen_vectors, eigen_values] = eig(square_matrix);");
        engEvalString(ep, "disp('特征值:'); disp(eigen_values)");
        engEvalString(ep, "disp('特征向量:'); disp(eigen_vectors)");
        
        // ==================== 测试4: 数值积分和微分方程 ====================
        std::cout << "\n5. 数值计算测试..." << std::endl;
        
        // 5.1 数值积分
        engEvalString(ep, "fun = @(x) sin(x) + x.^2;");
        engEvalString(ep, "integral_result = integral(fun, 0, pi);");
        engEvalString(ep, "fprintf('∫(sin(x)+x²)dx 从 0 到 π = %.6f\\n', integral_result)");
        
        // 5.2 微分方程 (简单示例)
        engEvalString(ep, "t_span = [0, 10]; y0 = 1;");
        engEvalString(ep, "ode_fun = @(t, y) -0.5 * y;");
        engEvalString(ep, "[t, y] = ode45(ode_fun, t_span, y0);");
        engEvalString(ep, "fprintf('解微分方程 dy/dt = -0.5y, y(0)=1\\n')");
        engEvalString(ep, "fprintf('y(10) = %.6f\\n', y(end))");
        
        // ==================== 测试5: 数据分析和统计 ====================
        std::cout << "\n6. 数据分析和统计测试..." << std::endl;
        
        // 6.1 生成随机数据
        engEvalString(ep, "rng(42);");  // 设置随机种子
        engEvalString(ep, "data = 10 + 2*randn(1000, 1);");  // 正态分布数据
        
        // 6.2 统计分析
        engEvalString(ep, "data_mean = mean(data);");
        engEvalString(ep, "data_std = std(data);");
        engEvalString(ep, "data_median = median(data);");
        
        engEvalString(ep, "fprintf('统计分析 (1000个样本):\\n')");
        engEvalString(ep, "fprintf('  均值: %.4f\\n', data_mean)");
        engEvalString(ep, "fprintf('  标准差: %.4f\\n', data_std)");
        engEvalString(ep, "fprintf('  中位数: %.4f\\n', data_median)");
        
        // ==================== 测试6: 图形和可视化 ====================
        std::cout << "\n7. 图形可视化测试..." << std::endl;
        
        // 7.1 创建多个图形
        engEvalString(ep, "figure('Name', '高级测试图形', 'NumberTitle', 'off');");
        
        // 子图1: 函数图像
        engEvalString(ep, "subplot(2, 3, 1);");
        engEvalString(ep, "x = linspace(-2*pi, 2*pi, 200);");
        engEvalString(ep, "y1 = sin(x); y2 = cos(x);");
        engEvalString(ep, "plot(x, y1, 'r-', x, y2, 'b--', 'LineWidth', 2);");
        engEvalString(ep, "title('sin(x) 和 cos(x)'); legend('sin(x)', 'cos(x)'); grid on;");
        
        // 子图2: 矩阵可视化
        engEvalString(ep, "subplot(2, 3, 2);");
        engEvalString(ep, "imagesc(square_matrix); colorbar; title('矩阵热图');");
        
        // 子图3: 3D图形
        engEvalString(ep, "subplot(2, 3, 3);");
        engEvalString(ep, "[X, Y] = meshgrid(-2:0.2:2, -2:0.2:2);");
        engEvalString(ep, "Z = X .* exp(-X.^2 - Y.^2);");
        engEvalString(ep, "surf(X, Y, Z); title('3D曲面'); shading interp;");
        
        // 子图4: 直方图
        engEvalString(ep, "subplot(2, 3, 4);");
        engEvalString(ep, "histogram(data, 30); title('数据直方图'); grid on;");
        
        // 子图5: 极坐标图
        engEvalString(ep, "subplot(2, 3, 5);");
        engEvalString(ep, "theta = linspace(0, 2*pi, 100); r = 2 + cos(5*theta);");
        engEvalString(ep, "polarplot(theta, r, 'LineWidth', 2); title('极坐标图');");
        
        // 子图6: 散点图
        engEvalString(ep, "subplot(2, 3, 6);");
        engEvalString(ep, "x_scatter = randn(50,1); y_scatter = x_scatter + 0.5*randn(50,1);");
        engEvalString(ep, "scatter(x_scatter, y_scatter, 50, 'filled'); title('散点图'); grid on;");
        
        engEvalString(ep, "sgtitle('C++/MATLAB 高级测试 - 多种图形类型');");
        
        std::cout << "✓ 图形窗口已创建，请查看 MATLAB 图形窗口" << std::endl;
        
        // ==================== 测试7: 文件操作和数据处理 ====================
        std::cout << "\n8. 文件操作测试..." << std::endl;
        
        // 8.1 保存数据到 MAT 文件
        engEvalString(ep, "save('test_data.mat', 'complex_matrix', 'square_matrix', 'data');");
        engEvalString(ep, "disp('数据已保存到 test_data.mat')");
        
        // 8.2 验证保存的数据
        engEvalString(ep, "clear; load('test_data.mat');");
        engEvalString(ep, "disp('重新加载的数据:'); whos");
        
        // ==================== 测试8: 性能测试 ====================
        std::cout << "\n9. 性能测试..." << std::endl;
        
        // 9.1 矩阵乘法性能
        engEvalString(ep, "A = rand(500, 500); B = rand(500, 500);");
        engEvalString(ep, "tic; C = A * B; matlab_time = toc;");
        engEvalString(ep, "fprintf('500x500 矩阵乘法时间: %.4f 秒\\n', matlab_time)");
        
        std::cout << std::endl;
        std::cout << "==========================================" << std::endl;
        std::cout << "🎉 高级测试完成！" << std::endl;
        std::cout << "所有高级功能正常工作" << std::endl;
        std::cout << "请查看 MATLAB 图形窗口中的可视化结果" << std::endl;
        std::cout << "按 Enter 键关闭 MATLAB 引擎..." << std::endl;
        std::cout << "==========================================" << std::endl;
        std::cin.get();
        
        // 清理资源
        mxDestroyArray(matlabMatrix);
        mxDestroyArray(matlabSquareMatrix);
        mxDestroyArray(cppString);
        engClose(ep);
        
        std::cout << "MATLAB 引擎已关闭" << std::endl;
        
    } catch (const std::exception& e) {
        std::cerr << "错误: " << e.what() << std::endl;
        return EXIT_FAILURE;
    }
    
    return EXIT_SUCCESS;
}

运行结果：

测试代码3：求解非线性方程组

Matlab求解非线性方程组直接用已经封装好了的函数fsolve来求解，非常简单；但c++求解非线性方程组的话就有点麻烦，一般用牛顿法求解，这要从头开始编程写算法了。c++求解非线性方程组的方法请参考书籍《常用算法程序集（C++描述）（第6版），作者: 徐士良， 出版社: 清华大学出版社 》的第五章。

下面直接给出c++直接调用matlab求解非线性方程组的代码

#include <iostream>
#include <cstdlib>
#include <vector>
#include <cmath>
#include <sstream>
#include <windows.h>
#include "engine.h"

template<typename T>
std::string toString(T value) {
    std::ostringstream oss;
    oss << value;
    return oss.str();
}

class MatlabEngineTester {
private:
    Engine* ep;

public:
    MatlabEngineTester() : ep(nullptr) {
        SetDllDirectoryA("I:\\software\\matlab2024b\\bin\\win64");
        ep = engOpen(NULL);
        if (!ep) throw std::runtime_error("无法启动MATLAB引擎");
        std::cout << "✓ MATLAB引擎启动成功" << std::endl;
        
        // 启用输出缓冲以捕获MATLAB输出
        engOutputBuffer(ep, NULL, 0);
    }

    ~MatlabEngineTester() {
        if (ep) {
            engClose(ep);
            std::cout << "✓ MATLAB引擎已关闭" << std::endl;
        }
    }

    // 执行命令并显示输出
    void executeCommand(const std::string& cmd, const std::string& description = "") {
        if (!description.empty()) {
            std::cout << "\n>>> " << description << ":" << std::endl;
        }
        std::cout << "  执行: " << cmd << std::endl;
        
        int result = engEvalString(ep, cmd.c_str());
        if (result != 0) {
            std::cout << "  返回代码: " << result << " (可能有错误)" << std::endl;
        }
    }

    // 检查变量是否存在并显示其值
    void checkVariable(const std::string& varName) {
        mxArray* var = engGetVariable(ep, varName.c_str());
        if (var) {
            if (mxIsDouble(var)) {
                double* data = mxGetPr(var);
                size_t numElements = mxGetNumberOfElements(var);
                std::cout << "  ✓ " << varName << " = [";
                for (size_t i = 0; i < numElements; i++) {
                    std::cout << data[i];
                    if (i < numElements - 1) std::cout << ", ";
                }
                std::cout << "]" << std::endl;
            } else if (mxIsChar(var)) {
                char* str = mxArrayToString(var);
                std::cout << "  ✓ " << varName << " = '" << (str ? str : "NULL") << "'" << std::endl;
                if (str) mxFree(str);
            } else {
                std::cout << "  ✓ " << varName << " (类型: " << mxGetClassName(var) << ")" << std::endl;
            }
            mxDestroyArray(var);
        } else {
            std::cout << "  ✗ " << varName << " 不存在" << std::endl;
        }
    }

    // 显示工作区所有变量
    void showWorkspace() {
        std::cout << "\n=== MATLAB工作区 ===" << std::endl;
        executeCommand("whos", "工作区变量列表");
    }

    // 测试优化工具箱
    bool testOptimizationToolbox() {
        std::cout << "\n=== 测试优化工具箱 ===" << std::endl;
        
        // 检查优化工具箱是否安装
        executeCommand("v = ver('optim');", "检查优化工具箱");
        checkVariable("v");
        
        // 检查fsolve函数
        executeCommand("fsolve_info = which('fsolve');", "检查fsolve路径");
        checkVariable("fsolve_info");
        
        // 测试一个非常简单的优化问题
        executeCommand("clear;", "清除工作区");
        executeCommand("simple_fun = @(x) x^2 - 4;", "定义简单函数");
        executeCommand("x0 = 1;", "设置初始值");
        executeCommand("[x_sol, fval, exitflag] = fsolve(simple_fun, x0);", "求解简单问题");
        
        checkVariable("x_sol");
        checkVariable("fval");
        checkVariable("exitflag");
        
        mxArray* exitflag = engGetVariable(ep, "exitflag");
        bool success = (exitflag != nullptr);
        if (exitflag) mxDestroyArray(exitflag);
        
        return success;
    }

    // 测试二维方程组
    bool test2DSystem() {
        std::cout << "\n=== 测试二维方程组 ===" << std::endl;
        executeCommand("clear;", "清除工作区");
        
        // 使用函数句柄而不是函数文件
        executeCommand("fun2d = @(x) [exp(-exp(-(x(1)+x(2)))) - x(2)*(1+x(1)^2); x(1)*cos(x(2)) + x(2)*sin(x(1)) - 0.5];", 
                      "定义二维方程组");
        
        executeCommand("x0 = [0.5, 0.5];", "设置初始值");
        executeCommand("options = optimset('Display', 'iter');", "设置选项");
        executeCommand("[x_sol, fval, exitflag] = fsolve(fun2d, x0, options);", "求解方程组");
        
        checkVariable("x_sol");
        checkVariable("fval"); 
        checkVariable("exitflag");
        
        // 检查是否成功
        mxArray* exitflag = engGetVariable(ep, "exitflag");
        bool success = (exitflag != nullptr);
        if (exitflag) mxDestroyArray(exitflag);
        
        return success;
    }

    // 替代方法：使用不同的求解器
    void testAlternativeMethods() {
        std::cout << "\n=== 测试替代方法 ===" << std::endl;
        executeCommand("clear;", "清除工作区");
        
        // 方法1: 使用fminunc
        std::cout << "\n方法1: 使用fminunc" << std::endl;
        executeCommand("fun2d = @(x) [exp(-exp(-(x(1)+x(2)))) - x(2)*(1+x(1)^2); x(1)*cos(x(2)) + x(2)*sin(x(1)) - 0.5];", 
                      "定义方程组");
        executeCommand("obj_fun = @(x) sum(fun2d(x).^2);", "创建目标函数（最小二乘）");
        executeCommand("x0 = [0.5, 0.5];", "设置初始值");
        executeCommand("[x_sol, fval] = fminunc(obj_fun, x0);", "使用fminunc求解");
        checkVariable("x_sol");
        checkVariable("fval");
        
        // 方法2: 使用lsqnonlin
        std::cout << "\n方法2: 使用lsqnonlin" << std::endl;
        executeCommand("[x_sol2, resnorm] = lsqnonlin(fun2d, x0);", "使用lsqnonlin求解");
        checkVariable("x_sol2");
        checkVariable("resnorm");
    }
};

int main() {
    try {
        std::cout << "=== MATLAB引擎详细测试 ===" << std::endl;
        
        MatlabEngineTester tester;
        
        // 测试基本功能
        tester.executeCommand("version", "MATLAB版本");
        tester.checkVariable("ans");
        
        tester.executeCommand("2 + 3 * 4", "基本计算");
        tester.checkVariable("ans");
        
        // 测试优化工具箱
        bool optimSuccess = tester.testOptimizationToolbox();
        std::cout << "\n优化工具箱测试: " << (optimSuccess ? "✓ 成功" : "✗ 失败") << std::endl;
        
        if (optimSuccess) {
            // 测试二维方程组
            bool systemSuccess = tester.test2DSystem();
            std::cout << "\n二维方程组测试: " << (systemSuccess ? "✓ 成功" : "✗ 失败") << std::endl;
            
            if (!systemSuccess) {
                std::cout << "\n方程组求解失败，尝试替代方法..." << std::endl;
                tester.testAlternativeMethods();
            }
        } else {
            std::cout << "\n!!! 优化工具箱测试失败 !!!" << std::endl;
            std::cout << "可能的原因:" << std::endl;
            std::cout << "1. Optimization Toolbox 未安装" << std::endl;
            std::cout << "2. MATLAB许可证问题" << std::endl;
            std::cout << "3. 路径配置问题" << std::endl;
        }
        
        // 显示最终工作区
        tester.showWorkspace();
        
    } catch (const std::exception& e) {
        std::cerr << "错误: " << e.what() << std::endl;
        return EXIT_FAILURE;
    }
    
    std::cout << "\n=== 测试完成 ===" << std::endl;
    return EXIT_SUCCESS;
}

运行结果如下

=== MATLAB引擎详细测试 ===
? MATLAB引擎启动成功

>>> MATLAB版本:
  执行: version
  ? ans = '24.2.0.2712019 (R2024b)'

>>> 基本计算:
  执行: 2 + 3 * 4
  ? ans = [14]

=== 测试优化工具箱 ===

>>> 检查优化工具箱:
  执行: v = ver('optim');
  ? v (类型: struct)

>>> 检查fsolve路径:
  执行: fsolve_info = which('fsolve');
  ? fsolve_info = 'I:\software\matlab2024b\toolbox\optim\optim\fsolve.m'

>>> 清除工作区:
  执行: clear;

>>> 定义简单函数:
  执行: simple_fun = @(x) x^2 - 4;

>>> 设置初始值:
  执行: x0 = 1;

>>> 求解简单问题:
  执行: [x_sol, fval, exitflag] = fsolve(simple_fun, x0);
  ? x_sol = [2]
  ? fval = [0]
  ? exitflag = [1]

优化工具箱测试: ? 成功

=== 测试二维方程组 ===

>>> 清除工作区:
  执行: clear;

>>> 定义二维方程组:
  执行: fun2d = @(x) [exp(-exp(-(x(1)+x(2)))) - x(2)*(1+x(1)^2); x(1)*cos(x(2)) + x(2)*sin(x(1)) - 0.5];

>>> 设置初始值:
  执行: x0 = [0.5, 0.5];

>>> 设置选项:
  执行: options = optimset('Display', 'iter');

>>> 求解方程组:
  执行: [x_sol, fval, exitflag] = fsolve(fun2d, x0, options);
  ? x_sol = [0.353247, 0.606082]
  ? fval = [1.59704e-10, -7.00395e-10]
  ? exitflag = [1]

二维方程组测试: ? 成功

=== MATLAB工作区 ===

>>> 工作区变量列表:
  执行: whos
? MATLAB引擎已关闭

=== 测试完成 ===

Process finished with exit code 0