Bewährte Methoden zum Definieren von Variablen für C/C++ Codegenerierung

Wenn Sie Code aus einem MATLAB Function-Block generieren möchten, muss der MATLAB^®-Code im Block den Anforderungen für die C/C++ Code-Generierung entsprechen. Einige Programmierpraktiken, die im MATLAB-Code funktionieren, funktionieren nicht bei der Code-Generierung. Befolgen Sie diese bewährten Verfahren, um Ihren Code zu optimieren und Simulationsfehler zu vermeiden.

Variablen vor der Verwendung explizit definieren

Für die C/C++ Codegenerierung müssen Sie Variablenwerte und -Eigenschaften explizit definieren, bevor Sie diese in Operationen verwenden oder als Ausgaben ausgeben können. Hierdurch werden Fehler vermieden, die auftreten, wenn die Variable nicht definiert wird.

Hinweis

Wenn Sie Variablen definieren, sind diese standardmäßig lokal und bestehen nicht über Funktionsaufrufe hinweg. Verwenden Sie die Funktion persistent, um Variablen persistent zu machen.

Variablen auf allen Ausführungspfaden definieren

Sie müssen eine Variable auf allen Ausführungspfaden definieren, wie den von if-Ausdrücken vorgegebenen Ausführungspfaden. Betrachten Sie diesen MATLAB Programmcode, der eine Variable definiert, bevor sie als Eingabe für eine Funktion verwendet wird:

...
if c <= 0
  x = 11;
end
% Later in your code ...
if c > 0
% Use x in the function foo
  foo(x);
end
...

Der Code weist x nur einem Wert zu, wenn c <= 0 und verwendet x nur, wenn c > 0. Je nach dem Wert von c kann dieser Code in MATLAB fehlerfrei funktionieren. Die Codegenerierung schlägt jedoch fehl, wenn Sie versuchen, C/C++ Code aus diesem MATLAB Programmcode zu generieren, da der Codegenerator erkennt, dass x auf dem Ausführungspfad undefiniert ist, wenn c > 0.

Um diesen Code für die Codegenerierung geeignet zu machen, definieren Sie x vor der Verwendung:

x = 0;
...
if c <= 0
  x = 11;
end
% Later in your code ...
if c > 0
% Use x in the function foo
  foo(x);
end
...

Alle Strukturfelder definieren

Sie müssen zudem jedes Strukturfeld für alle Ausführungspfade definieren. Betrachten Sie diesen MATLAB Programmcode:

...
if c > 0 
  s.a = 11;
  disp(s);
else
  s.a = 12;
  s.b = 12;
end
% Use s in the function foo
foo(s);
...

Der erste Teil des Ausdrucks if verwendet nur das Feld a und der Ausdruck else verwendet die Felder a und b. Dieser Code funktioniert in MATLAB, erzeugt jedoch bei der C/C++ Codegenerierung einen Kompilierungsfehler. Um diesen Fehler zu vermeiden, fügen Sie einer Struktur keine Felder hinzu, nachdem Sie die Struktur verwenden. Weitere Informationen finden Sie unter Strukturdefinition für die Codegenerierung.

Um diesen Code für die C/C++ Codegenerierung geeignet zu machen, definieren Sie die Felder von s vor der Verwendung:

...
% Define fields in structure s
s = struct("a", 0, "b", 0);
if c > 0 
  s.a = 11;
  disp(s);
else
  s.a = 12;
  s.b = 12;
end
% Use s in the function foo
foo(s);
...

Vorsicht bei der Neuzuweisung von Variablen-Eigenschaften

Nach der anfänglichen Zuweisung können Sie bestimmten Variablen einen Wert mit einer anderen Klasse, Größe oder Komplexität neu zuweisen. Siehe Reassignment of Variable Properties. Wenn Sie den Variablentyp jedoch nach der ersten Zuweisung neu zuweisen, gibt der Code oft während der Codegenerierung einen Kompilierungsfehler aus. Im Allgemeinen sollten Sie jeder Variable eine spezifische Klasse, Größe und Komplexität sowie einen spezifischen Typ zuweisen.

Variable numerische Datentypen definieren

double ist der numerische Standard-Datentyp in MATLAB. Um Variablen mit anderen Datentypen zu definieren, müssen Sie den Datentyp in der Definition explizit mit dem korrekten Präfix oder Operator festlegen. Achten Sie hierbei auf die benutzten Datentypen, da die Verwendung von Variablen, die unterschiedlichen Datentypen zugewiesen sind, zu Fehlern durch Typverletzung führen kann.

In diesem Code ist beispielsweise die Variable x als Double und y als 8-Bit-Integer definiert:

x = 15;
y = uint8(x);

Weitere Informationen zu unterstützten Typen in MATLAB finden Sie unter Numerische Typen.

Matrizen definieren, bevor indizierte Variablen zugewiesen werden

Wenn Sie eine Variable vergrößern, indem Sie ein Element über dessen aktuelle Größe hinaus schreiben, führt dies zu einem Fehler bei der Kompilierung oder Laufzeit, wenn Sie keine End+1-Indizierung verwenden oder die Variable anderweitig als variable Größe definieren. Siehe Generate Code for Growing Arrays and Cell Arrays with end + 1 Indexing (MATLAB Coder) und Define Variable-Size Data for Code Generation. Sie können Ausgabevariablen auch als variable Größe im Bereich Symbols und im Property Inspector angeben. Siehe Declare Variable-Size MATLAB Function Block Variables. Um größenbedingte Fehler zu vermeiden, ohne die End + 1-Indizierung zu verwenden oder Arrays als variable Größe zu definieren, definieren Sie die maximale Größe des Arrays, bevor Sie seinen Elementen Werte zuweisen.

Diese Zuweisung führt beispielsweise zu einem Fehler bei der Codegenerierung:

g = zeros(3,3);
g(5,2) = 14.6;

Korrigieren Sie diesen Code, indem Sie eine Matrix g mit ausreichender Größe definieren:

g = zeros(5,5);
g(5,2) = 14.6;

Weitere Informationen zur Indizierung von Matrizen finden Sie unter Incompatibility with MATLAB in Matrix Indexing Operations for Code Generation.

Arrays nach Möglichkeit mithilfe von Vektoren fester Größe indizieren

Obwohl die Codegenerierung Arrays variabler Größe unterstützt, benötigen diese Arrays variabler Größe zusätzlichen Speicher, was die Leistung beeinträchtigen kann. Verwenden Sie nach Möglichkeit Vektoren mit konstantem Wert, um Arrays zu indizieren. Beispiel:

...
% extract 7 elements from A using a constant-value vector
B = A(1:7);
...

In diesem Beispiel erkennt der Codegenerator, dass B eine feste Größe hat.

Wenn Sie mithilfe des Operators colon und Variablenwerten in ein Array indizieren, kann der Codegenerator nicht immer korrekt ermitteln, ob das Array eine feste oder variable Größe aufweist. Beide der folgenden Arrays weisen beispielsweise unabhängig vom Wert von i eine feste Größe auf:

...
% extract 7 elements from A using a fixed-size vector
B = A(i-1:i+5);
C = A(-1+2*i:5+2*i);
...

Wenn der Wert von i zum Zeitpunkt der Codegenerierung bekannt ist, erkennt der Codegenerator sowohl B und C als Arrays fester Größe. Wenn der Wert von i zum Zeitpunkt der Codegenerierung jedoch nicht bekannt ist, erkennt der Codegenerator B als feste Größe, definiert C jedoch als variable Größe. Dementsprechend ist es möglich, dass Sie ein Array definieren, das seine Größe nicht ändert und entsprechend eine feste Größe aufweist, vom Codegenerator jedoch als Array variabler Größe angesehen und spezifiziert wird.

In einigen solchen Fällen können Sie Ihren MATLAB Programmcode umschreiben, um den Codegenerator dazu zu zwingen, zu erkennen, dass das definierte Array seine Größe nicht ändert. Beispielsweise können Sie die obenstehende Definition von C umschreiben, um den Array-Indizierungsausdruck aus den mathematischen Operationen mit der Variable (i), die zum Zeitpunkt der Codegenerierung unbekannt ist, zu extrahieren:

...
% extract 7 elements from A using a fixed-size vector
C = A(2*i+(-1:5));
...

Nach diesem Umschreiben erkennt der Codegenerator C als Array fester Größe.

Bei einigen anderen Code-Mustern umfassen die Array-Indizes Variablen, die sich auf die Arraygröße auswirken; diese Variablen sind zum Kompilierungszeitpunkt jedoch bekannt. In diesen Situationen weist das extrahierte Array tatsächlich eine feste Größe auf, der Codegenerator könnte es jedoch nicht als Array fester Größe erkennen und dementsprechend als variable Größe behandeln. Gelegentlich können Sie derartigen Code auch umschreiben, um Arrays fester Größe zu generieren. In diesem Beispiel sind die Arrays D_varSize und D_fixSize identisch. Der Codegenerator definiert jedoch D_varSize als variable Größe und D_fixSize als feste Größe:

...
width = 25;              
D_varSize = A(i-width:i+width);  % D_varSize is variable-size if i is unknown at compile time 
D_fixSize = A(i+(-width:width)); % D_fixSize is fixed-size whether or not i is unknown at compile time
...

Siehe auch

coder.nullcopy | persistent | coder.extrinsic