Erstellen einer ausführbaren C++ Datei über die Befehlszeile
Dieses Beispiel veranschaulicht, wie Sie mithilfe des Befehls codegen eine ausführbare C++ Datei aus einer MATLAB®-Funktion generieren können. In diesem Beispiel bereiten Sie eine Einstiegsfunktion für die Codegenerierung vor, legen die Eingabetypen fest und generieren anschließend eine MEX-Funktion, eine main-Beispielfunktion in C++ sowie eine einfache ausführbare C++ Datei. Um die Grundlagen der Codegenerierung zu erlernen, besuchen Sie Generate Deployable Standalone Code by Using the MATLAB Coder App.
Untersuchen einer MATLAB-Funktion und Generieren von Beispieldaten
Untersuchen Sie die MATLAB-Funktion averagingFilterML. Diese Funktion entfernt Rauschen aus einem Eingangssignal mithilfe eines Mittelwertfilters. Sie nimmt einen Eingangsvektor mit Signalwerten entgegen und gibt einen Ausgangsvektor mit gefilterten Werten zurück, der dieselbe Größe wie der Eingangsvektor aufweist. Die averagingFilterML-Funktion verwendet die Variable slider zur Darstellung eines Zeitfensters mit 16 Signalwerten und berechnet für jede Fensterposition den Signal-Durchschnittswert.
type averagingFilterMLfunction y = averagingFilterML(x)
slider = zeros(16,1);
for i = 1:numel(x)
slider(2:end) = slider(1:end-1); % move one position in the buffer
slider(1) = x(i); % Add a new sample value to the buffer
y(i) = sum(slider)/numel(slider); % write the average of the current window to y
end
end
Generieren Sie eine verrauschte Sinuswelle und verwenden Sie averagingFilterML, um die verrauschten Daten zu filtern und zu plotten.
v = 0:0.00614:2*pi; x = sin(v) + 0.3*rand(1,numel(v)); filtered_ML = averagingFilterML(x); plot(x,"red"); hold on plot(filtered_ML,"blue"); xlim([0 1000]) hold off;
Vorbereiten der Einstiegsfunktion für die Codegenerierung
Bereiten Sie die Einstiegsfunktion für die Codegenerierung vor. Eine Einstiegsfunktion ist eine Funktion auf oberster Ebene, die alle anderen MATLAB-Funktionen aufruft, für die Sie Code generieren möchten. In diesem Beispiel verwenden Sie averagingFilterML als Einstiegsfunktion.
Um averagingFilterML für die Codegenerierung vorzubereiten, bearbeiten Sie die Funktion.
edit averagingFilterMLFügen Sie die Anweisung %#codegen nach der Funktionsdeklaration averagingFilterML ein. Diese Anweisung veranlasst den MATLAB Code Analyzer, Warnungen und Fehler zu identifizieren, die speziell mit der Codegenerierung zusammenhängen. In diesem Beispiel weist der Code Analyzer darauf hin, dass Sie das Ausgabeargument y vollständig definieren müssen, bevor Sie es verwenden. Weitere Informationen zu den vom Code Analyzer durchgeführten Prüfungen finden Sie unter MATLAB for Code Generation Messages.
Der Codegenerator muss in der Lage sein, die Größe und den Typ eines Arrays zu ermitteln, bevor Sie auf ein Element des Arrays zugreifen. In diesem Beispiel müssen Sie die Größe und den Typ des Arrays y festlegen, bevor Sie das Element y(i) aktualisieren. Sie können die Funktion zeros verwenden, um anzugeben, dass es sich bei y um ein 1-mal-x-Array aus Doubles handelt. Fügen Sie die folgende Codezeile nach der Funktionsdeklaration ein:
y = zeros(size(x));
Nachdem Sie diese Änderung vorgenommen haben, erkennt der Code Analyzer keine weiteren potenziellen Fehler bei der Codegenerierung im Code. Die Datei averagingFilterCG.m enthält den aktualisierten Code.
Verwenden Sie die Funktion coder.screener, um das Tool zur Überprüfung der Codegenerierungsbereitschaft auszuführen. Verwenden Sie dieses Tool, um zu überprüfen, ob der MATLAB Programmcode Funktionen oder Merkmale enthält, die bei der Codegenerierung nicht unterstützt werden. Weitere Informationen zu den von diesem Tool durchgeführten Prüfungen finden Sie unter Code Generation Readiness Tool.
In diesem Beispiel findet das Tool zur Überprüfung der Codegenerierungsbereitschaft keine nicht unterstützten Funktionen oder Merkmale in der Funktion averagingFilterCG.
coder.screener("averagingFilterCG")
Festlegen der Eingabetypen
Legen Sie den Typ der Eingabeparameter Ihrer Einstiegsfunktion fest. Da es sich bei C und C++ um statisch typisierte Sprachen handelt, muss der Codegenerator während der Codegenerierung die Klasse und die Größe aller Variablen im generierten Code ermitteln. Eine Möglichkeit, Eingabetypen festzulegen, ist die Verwendung eines arguments-Blocks. Weitere Informationen zu anderen Methoden der Eingabetypspezifikation finden Sie unter Specify Types of Entry-Point Function Inputs.
Fügen Sie diesen Code nach der Funktionsdeklaration ein, um das Eingabeargument x als unbegrenzten Zeilenvektor aus Doubles zu definieren:
arguments
x (1,:) double
end
Die Datei averagingFilter.m enthält den aktualisierten Code:
type averagingFilterfunction y = averagingFilter(x) %#codegen
arguments
x (1,:) double
end
y = zeros(size(x));
slider = zeros(16,1);
for i = 1:numel(x)
slider(2:end) = slider(1:end-1); % move one position in the buffer
slider(1) = x(i); % Add a new sample value to the buffer
y(i) = sum(slider)/numel(slider); % write the average of the current window to y
end
end
Generieren und Ausführen einer MEX-Funktion
Erstellen Sie aus Ihrer Einstiegsfunktion eine MEX-Funktion. Eine MEX-Funktion ist eine ausführbare C oder C++ Datei, die Sie innerhalb von MATLAB ausführen können. Führen Sie die generierte MEX-Funktion aus, um zu überprüfen, ob der generierte Code dasselbe Verhalten aufweist wie der ursprüngliche MATLAB Programmcode.
Es empfiehlt sich, diesen Schritt durchzuführen, da Sie die generierte MEX-Funktion ausführen können, um Laufzeitfehler zu erkennen, die in eigenständigem Code schwerer zu diagnostizieren sind. Beispielsweise führt die MEX-Funktion standardmäßig Speicherintegritätsprüfungen durch. Dabei werden Array-Grenz- und Dimensionsprüfungen durchgeführt, um Verstöße gegen die Speicherintegrität in dem für MATLAB-Funktionen generierten Code zu erkennen.
Standardmäßig erzeugt der Befehl codegen im Arbeitsordner eine MEX-Funktion in C. Verwenden Sie die Option -lang:C++, um den Codegenerator anzuweisen, eine C++ MEX-Funktion zu erzeugen.
codegen averagingFilter -lang:c++
Code generation successful.
Testen Sie die MEX-Funktion mit derselben Eingabe, die Sie an die ursprüngliche MATLAB-Funktion übergeben haben. In diesem Beispiel sind die Ausgabewerte der beiden Funktionen äquivalent innerhalb des Maschinenepsilons.
filtered_MEX = averagingFilter_mex(x); all(abs(filtered_ML-filtered_MEX)) < eps
ans = logical
1
Generieren einer main-Beispielfunktion in C++
Erstellen Sie eine main-Beispielfunktion in C++. Der Codegenerator erzeugt eine main-Beispielfunktion in C oder C++, wenn Sie eigenständigen Code generieren. Da die main-Beispielfunktion demonstriert, wie die generierte C oder C++ Funktion aufgerufen wird, können Sie sie als Vorlage für Ihre Anwendung verwenden. Verwenden Sie den Befehl codegen mit den Optionen -config:lib und -lang:c++, um eine eigenständige statische C++ Bibliothek zu generieren.
codegen -config:lib -lang:c++ averagingFilter
Code generation successful.
Sehen Sie sich dieses Beispiel für eine C++ main-Funktion an. Der Codegenerator erstellt die CPP- und H-Beispieldateien im Ordner codegen/lib/averagingFilter/examples.
type(fullfile("codegen","lib","averagingFilter","examples","main.cpp"))
//
// File: main.cpp
//
// MATLAB Coder version : 26.1
// C/C++ source code generated on : 19-Apr-2026 03:07:47
//
/*************************************************************************/
/* This automatically generated example C++ main file shows how to call */
/* entry-point functions that MATLAB Coder generated. You must customize */
/* this file for your application. Do not modify this file directly. */
/* Instead, make a copy of this file, modify it, and integrate it into */
/* your development environment. */
/* */
/* This file initializes entry-point function arguments to a default */
/* size and value before calling the entry-point functions. It does */
/* not store or use any values returned from the entry-point functions. */
/* If necessary, it does pre-allocate memory for returned values. */
/* You can use this file as a starting point for a main function that */
/* you can deploy in your application. */
/* */
/* After you copy the file, and before you deploy it, you must make the */
/* following changes: */
/* * For variable-size function arguments, change the example sizes to */
/* the sizes that your application requires. */
/* * Change the example values of function arguments to the values that */
/* your application requires. */
/* * If the entry-point functions return values, store these values or */
/* otherwise use them as required by your application. */
/* */
/*************************************************************************/
// Include Files
#include "main.h"
#include "averagingFilter.h"
#include "averagingFilter_initialize.h"
#include "averagingFilter_terminate.h"
#include "coder_array.h"
// Function Declarations
static coder::array<double, 2U> argInit_1xUnbounded_real_T();
static double argInit_real_T();
// Function Definitions
//
// Arguments : void
// Return Type : coder::array<double, 2U>
//
static coder::array<double, 2U> argInit_1xUnbounded_real_T()
{
coder::array<double, 2U> result;
// Set the size of the array.
// Change this size to the value that the application requires.
result.set_size(1, 2);
// Loop over the array to initialize each element.
for (int idx1{0}; idx1 < result.size(1); idx1++) {
// Set the value of the array element.
// Change this value to the value that the application requires.
result[idx1] = argInit_real_T();
}
return result;
}
//
// Arguments : void
// Return Type : double
//
static double argInit_real_T()
{
return 0.0;
}
//
// Arguments : int argc
// char **argv
// Return Type : int
//
int main(int, char **)
{
// Initialize the application.
// You do not need to do this more than one time.
averagingFilter_initialize();
// Invoke the entry-point functions.
// You can call entry-point functions multiple times.
main_averagingFilter();
// Terminate the application.
// You do not need to do this more than one time.
averagingFilter_terminate();
return 0;
}
//
// Arguments : void
// Return Type : void
//
void main_averagingFilter()
{
coder::array<double, 2U> x;
coder::array<double, 2U> y;
// Initialize function 'averagingFilter' input arguments.
// Initialize function input argument 'x'.
x = argInit_1xUnbounded_real_T();
// Call the entry-point 'averagingFilter'.
averagingFilter(x, y);
}
//
// File trailer for main.cpp
//
// [EOF]
//
Anpassen der main-Beispielfunktion in C++
Kopieren Sie die Beispieldatei main.cpp in das Arbeitsverzeichnis und passen Sie sie an Ihre Anwendung an. Verwenden Sie die generierte „main“-Beispieldatei als Ausgangspunkt für die Erstellung einer „main“-Funktion. Das Beispiel „main“ veranschaulicht, wie Eingaben an den generierten Code übergeben und Ausgaben aus diesem zurückgegeben werden.
Ändern Sie die Dateien main.c und main.h im examples-Unterordner nicht. Bevor Sie die „main“-Beispielfunktion verwenden, kopieren Sie deren Quell- und Header-Dateien an einen Speicherort außerhalb des Build-Ordners. Passen Sie die Dateien am neuen Speicherort an die Anforderungen Ihrer Anwendung an.
In diesem Beispiel enthält die Datei main.cpp im Arbeitsverzeichnis eine vereinfachte C++ main-Funktion.
type main.cpp#include "averagingFilter.h"
#include "averagingFilter_initialize.h"
#include "averagingFilter_terminate.h"
#include "coder_array.h"
#include <iostream>
int main()
{
coder::array<double, 2U> x = {1.0, 2.0};
coder::array<double, 2U> y;
averagingFilter_initialize();
averagingFilter(x, y);
averagingFilter_terminate();
std::cout << "Execution completed";
return 0;
}
Generieren und Testen einer ausführbaren C++ Datei
Weisen Sie den Codegenerator an, eine ausführbare C++ Datei zu erstellen, indem Sie den codegen-Befehl mit den Optionen -config:exe und -lang:c++ verwenden. Weisen Sie den codegen-Befehl dazu an, die benutzerdefinierte main.cpp-Quellcode-Datei einzubeziehen, indem Sie den Dateinamen in der Befehlszeile angeben. Der Codegenerator erstellt im Arbeitsordner die ausführbare Datei averagingFilter.
codegen -config:exe -lang:c++ averagingFilter main.cpp
Code generation successful.
Um die ausführbare Datei in MATLAB auszuführen, verwenden Sie den Befehl system. Verwenden Sie die Funktion ispc, um den entsprechenden system-Befehl auszuwählen.
if ispc system("averagingFilter.exe") else system("./averagingFilter") end
Execution completed
ans = 0
