struct

Strukturarray

Beschreibung

Ein Strukturarray ist ein Datentyp, der miteinander in Beziehung stehende Daten mit Datencontainern, die Felder genannt werden, gruppiert. Jedes Feld kann jeden beliebigen Datentyp enthalten. Greifen Sie auf Daten in einem Feld zu, indem Sie die Punktnotation in der Form structName.fieldName verwenden.

Erstellung

Wenn Sie Daten in eine neue Struktur eingeben müssen, erstellen Sie die Struktur mithilfe der Punktnotation, um ihre Felder nacheinander zu benennen:

s.a = 1;
s.b = {'A','B','C'}

s = struct with fields:
    a: 1
    b: {'A'  'B'  'C'}

Feldnamen können ASCII-Buchstaben (A–Z, a–z), Ziffern (0–9) und Unterstriche enthalten und müssen mit einem Buchstaben beginnen. Die maximale Länge eines Feldnamens ist namelengthmax.

Sie können ein Strukturarray auch mithilfe der Funktion struct, die im Folgenden beschrieben ist, erstellen. Sie können viele Felder gleichzeitig angeben oder ein nichtskalares Strukturarray erstellen.

Syntax

s = struct

s = struct(field,value)

s = struct(field1,value1,...,fieldN,valueN)

s = struct([])

s = struct(obj)

Beschreibung

s = struct erstellt eine Skalarstruktur (1x1) ohne Felder.

s = struct(field,value) erstellt ein Strukurarray mit dem angegebenen Feld und Wert. Das Eingabeargument value kann einen beliebigen Datentyp aufweisen, z. B. numerisch, logisch, Zeichen oder Zellenarray.

• Wenn value kein Zellenarray ist oder wenn value ein skalares Zellenarray ist, dann ist s eine skalare Struktur. Beispielsweise erstellt s = struct('a',[1 2 3]) eine 1x1-Struktur, wobei s.a = [1 2 3].

• Wenn value ein nichtskalares Zellenarray ist, dann ist s ein Strukturarray mit denselben Dimensionen wie value. Jedes Element von s enthält das entsprechende Element von value. Beispielsweise gibt s = struct('x',{'a','b'}) s(1).x = 'a' und s(2).x = 'b' zurück.

• Wenn value ein leeres Zellenarray {} ist, dann ist s eine leere Struktur (0x0).

s = struct(field1,value1,...,fieldN,valueN) erstellt ein Strukturarray mit mehreren Feldern.

• Wenn keine der value-Eingaben Zellenarrays sind oder wenn alle value-Eingaben, die Zellenarrays sind, Skalare sind, dann ist s eine skalare Struktur.

• Wenn eine der value-Eingaben ein nichtskalares Zellenarray ist, dann hat s dieselben Dimensionen wie dieses Zellenarray. Wenn zwei oder mehr value-Eingaben nichtskalare Zellenarrays sind, dann müssen alle dieselben Dimensionen aufweisen.

  Für jeden Wert (value), der ein skalares Zellenarray oder ein Array eines anderen Datentyps ist, fügt struct die Inhalte von value in das relevante Feld für alle Elemente von s ein. Beispielsweise gibt s = struct('x',{'a','b'},'y','c') s(1).x = 'a', s(2).x = 'b', s(1).y = 'c' und s(2).y = 'c' zurück.

• Wenn eine der value-Eingaben ein leeres Zellenarray ist, {}, dann ist die Ausgabe s eine leere Struktur (0x0). Wenn Sie ein leeres Feld angeben und die Werte anderer Felder beibehalten möchten, verwenden Sie stattdessen [] als value-Eingabe.

s = struct([]) erstellt eine leere Struktur (0x0) ohne Felder.

s = struct(obj) erstellt eine skalare Struktur mit Feldnamen und -werten, die den Eigenschaften von obj entsprechen. Die Funktion struct konvertiert obj nicht, sondern erstellt stattdessen s als neue Struktur. Diese Struktur behält die Klasseninformation nicht bei, sodass private, geschützte und verborgene Eigenschaften in s zu öffentlichen Feldern werden. Die Funktion struct gibt eine Warnung aus, wenn Sie diese Syntax verwenden.

Eingabeargumente

field — Feldname

Zeichenvektor | Zeichenfolgenskalar

Feldname, angegeben als Zeichenvektor oder Zeichenfolgenskalar.

value — Werte

Array

Werte, angegeben als beliebiger Array-Typ. Wenn eine der value-Eingaben ein nichtskalares Zellenarray ist, dann müssen alle nichtskalaren Zellenarray-Eingaben dieselben Dimensionen aufweisen.

Wenn eine der value-Eingaben ein leeres Zellenarray ist, {}, dann ist die Ausgabe ein leeres Strukturarray. Zum Angeben eines einzelnen leeren Felds verwenden Sie [].

obj — Objekt

Objekt

Die Funktion struct kopiert die Eigenschaften von obj in die Felder einer neuen Skalarstruktur.

Die Funktion struct erstellt aus den meisten der grundlegenden Datentypen keine Struktur. Wenn beispielsweise obj den Datentyp double oder char aufweist, gibt struct eine Fehlermeldung aus. Allerdings gibt struct die Eigenschaften einer Tabelle oder eines Timetable zurück. Eine Liste der grundlegenden Datentypen finden Sie unter Fundamental MATLAB Classes.

Beispiele

Speichern von in Beziehung stehenden Datenvariablen in einer Struktur

Speichern Sie in Beziehung stehende Datenelemente in den Feldern einer Struktur. Sie können den Feldern menschenlesbare Namen geben, die die Daten beschreiben.

Erstellen Sie eine Struktur, indem Sie dieser mithilfe der Punktnotation Felder hinzufügen. Die Felder enthalten x- und y-Werte für eine Sinuswelle sowie Text, der die Daten beschreibt.

data.x = linspace(0,2*pi);
data.y = sin(data.x);
data.title = 'y = sin(x)'

data = struct with fields:
        x: [0 0.0635 0.1269 0.1904 0.2539 0.3173 0.3808 0.4443 0.5077 0.5712 0.6347 0.6981 0.7616 0.8251 0.8885 0.9520 1.0155 1.0789 1.1424 1.2059 1.2693 1.3328 1.3963 1.4597 1.5232 1.5867 1.6501 1.7136 1.7771 1.8405 1.9040 1.9675 … ] (1×100 double)
        y: [0 0.0634 0.1266 0.1893 0.2511 0.3120 0.3717 0.4298 0.4862 0.5406 0.5929 0.6428 0.6901 0.7346 0.7761 0.8146 0.8497 0.8815 0.9096 0.9341 0.9549 0.9718 0.9848 0.9938 0.9989 0.9999 0.9969 0.9898 0.9788 0.9638 0.9450 0.9224 … ] (1×100 double)
    title: 'y = sin(x)'

Plotten Sie die Sinuswelle. Sie können auf die Arrays der x- und y-Werte mithilfe ihrer Feldnamen verweisen. Fügen Sie anschließend den Titel hinzu.

plot(data.x,data.y)
title(data.title)

Struktur mit einem Feld

Erstellen Sie eine nichtskalare Struktur, die ein einzelnes Feld enthält.

field = 'f';
value = {'some text';
         [10, 20, 30];
         magic(5)};
s = struct(field,value)

s=3×1 struct array with fields:
    f

Zeigen Sie die Inhalte jedes Elements an.

s.f

ans = 
'some text'

ans = 1×3

    10    20    30

ans = 5×5

    17    24     1     8    15
    23     5     7    14    16
     4     6    13    20    22
    10    12    19    21     3
    11    18    25     2     9

Wenn Sie auf ein Feld einer nichtskalaren Struktur zugreifen, z. B. s.f, gibt MATLAB® eine durch Kommas getrennte Liste zurück. In diesem Fall ist s.f äquivalent zu s(1).f, s(2).f, s(3).f.

Struktur mit mehreren Feldern

Erstellen Sie eine nichtskalare Struktur, die mehrere Felder enthält.

field1 = 'f1';  value1 = zeros(1,10);
field2 = 'f2';  value2 = {'a', 'b'};
field3 = 'f3';  value3 = {pi, pi.^2};
field4 = 'f4';  value4 = {'fourth'};

s = struct(field1,value1,field2,value2,field3,value3,field4,value4)

s=1×2 struct array with fields:
    f1
    f2
    f3
    f4

Die Zellenarrays für value2 und value3 haben die Größe 1x2, weshalb auch s 1x2 ist. Da value1 ein numerisches Array und kein Zellenarray ist, haben s(1).f1 und s(2).f1 dieselben Inhalte. Analog dazu haben s(1).f4 und s(2).f4 dieselben Inhalte, da das Zellenarray für value4 über ein einzelnes Element verfügt.

s(1)

ans = struct with fields:
    f1: [0 0 0 0 0 0 0 0 0 0]
    f2: 'a'
    f3: 3.1416
    f4: 'fourth'

s(2)

ans = struct with fields:
    f1: [0 0 0 0 0 0 0 0 0 0]
    f2: 'b'
    f3: 9.8696
    f4: 'fourth'

Struktur mit leerem Feld

Erstellen Sie eine Struktur, die ein leeres Feld enthält. Verwenden Sie [], um den Wert des leeren Felds anzugeben.

s = struct('f1','a','f2',[])

s = struct with fields:
    f1: 'a'
    f2: []

Felder mit Zellenarrays

Erstellen Sie eine Struktur mit einem Feld, das ein Zellenarray enthält.

field = 'mycell';
value = {{'a','b','c'}};
s = struct(field,value)

s = struct with fields:
    mycell: {'a'  'b'  'c'}

Leere Struktur

Erstellen Sie eine leere Struktur, die mehrere Felder enthält.

s = struct('a',{},'b',{},'c',{})

s = 

  0×0 empty struct array with fields:

    a
    b
    c

Weisen Sie einem Feld in einer leeren Struktur einen Wert zu.

s(1).a = 'a'

s = struct with fields:
    a: 'a'
    b: []
    c: []

Verschachtelte Struktur

Erstellen Sie eine verschachtelte Struktur, wobei a eine Struktur mit einem Feld ist, das eine weitere Struktur enthält.

a.b = struct('c',{},'d',{})

a = struct with fields:
    b: [0×0 struct]

Zeigen Sie die Namen der Felder von a.b an.

fieldnames(a.b)

ans = 2×1 cell
    {'c'}
    {'d'}

Erweiterte Fähigkeiten

C/C++ Codegenerierung

Generieren Sie C und C++ Code mit MATLAB® Coder™.

Hinweise zur Verwendung und Einschränkungen:

• Wenn das Argument value ein Zellenarray ist, müssen alle Elemente denselben Typ aufweisen.

• Die Feldnamen des Strukturarrays müssen alle dieselbe Länge haben. Beispielsweise führt dieser Code zu einem Fehler, weil 'my_int' und 'my_double' unterschiedliche Längen haben:

  param1.name = 'my_int';
  param1.value = int32(1);
  param2.name = 'my_double';
  param2.value = 2.0;
  params = [param1, param2];

Thread-Based Environment

Führen Sie mithilfe von MATLAB® backgroundPool den Code im Hintergrund aus oder machen Sie den Code mit der Parallel Computing Toolbox™ ThreadPool schneller.

Diese Funktion bietet vollständige Unterstützung für thread-basierte Umgebungen. Weitere Informationen finden Sie unter Run MATLAB Functions in Thread-Based Environment.

Versionsverlauf

Eingeführt vor R2006a

R2023b: Es werden Teilinhalte sowie Größe und Datentyp der Arrays in Strukturfeldern angezeigt

Von R2021b bis R2023b zeigte MATLAB^® alle Inhalte eines Arrays in einem Strukturfeld an, wenn in der Anzeige ausreichend Platz für die Inhalte vorhanden war. Wenn für das Array nicht genug Platz vorhanden war, zeigte MATLAB so viel vom Array an, wie der Platz in der Anzeige erlaubte.

In Releases ab R2023b zeigt MATLAB, sofern nicht alle Inhalte eines Arrays in einem Feld in der Anzeige Platz finden, so viel des Arrays an, wie die Anzeige erlaubt. Zusätzlich werden noch die Größe und der Datentyp des Arrays angezeigt. Beispielsweise zeigt MATLAB in Releases ab R2023b Teilinhalte sowie Größe und Datentyp von zwei Feldern an, die Arrays mit 100 doppelten Werten enthalten.

data.x = linspace(0,2*pi);
data.y = sin(data.x);
data

data = 

  struct with fields:

    x: [0 0.0635 0.1269 0.1904 0.2539 0.3173 0.3808 … ] (1×100 double)
    y: [0 0.0634 0.1266 0.1893 0.2511 0.3120 0.3717 … ] (1×100 double)

Wenn das erste Element des Arrays selbst zu groß für die Anzeige ist, z. B. ein Aufzählungsmitglied mit einem langen Namen, zeigt MATLAB nur die Größe und den Datentyp des Arrays an.

Die Funktion disp weist dasselbe Verhalten auf.

R2021b: Teilinhalte von Arrays in Strukturfeldern werden anstelle von Größe und Datentyp angezeigt

In Releases vor R2021b zeigte MATLAB alle Inhalte eines Arrays in einem Strukturfeld an, sofern die Inhalte in der Anzeige Platz fanden. Wenn für das Array nicht genug Platz vorhanden war, zeigte MATLAB nur die Größe und den Datentyp des Arrays an.

In Releases ab R2021b zeigt MATLAB, sofern nicht alle Inhalte eines Arrays in der Anzeige Platz finden, anstelle der Größe und des Datentyps so viel des Arrays an, wie die Anzeige erlaubt. Beispielsweise zeigt MATLAB in Releases ab R2021b Teilinhalte von zwei Strukturfeldern an, die Arrays mit 100 doppelten Werten enthalten.

data.x = linspace(0,2*pi);
data.y = sin(data.x);
data

data = 

  struct with fields:

     x: [0 0.0635 0.1269 0.1904 0.2539 0.3173 0.3808 0.4443 0.5077 … ]
     y: [0 0.0634 0.1266 0.1893 0.2511 0.3120 0.3717 0.4298 0.4862 … ]

Wenn das erste Element des Arrays selbst zu groß für die Anzeige ist, z. B. ein Aufzählungsmitglied mit einem langen Namen, zeigt MATLAB nur die Größe und den Datentyp des Arrays an.

Die Funktion disp weist dasselbe Verhalten auf.

R2019a: Die Erweiterung von Strukturarrays ist vergleichbar mit der Erweiterung allgemeiner Arrays

In Releases ab R2019a sind die Dimensionen eines erweiterten Strukturarrays stets identisch, unabhängig davon, ob Sie einen Wert mithilfe der Punktnotation einem einzelnen Feld zuweisen oder ob Sie dem Array eine ganze Struktur zuweisen. Zuvor unterschieden sich die Ausgabedimensionen, wenn Sie nicht für alle Dimensionen Indizes angaben. Zuweisungen zu einem Feld mithilfe der Punktnotation stimmen jetzt mit dem vorherigen Verhalten beim Zuweisen einer Struktur überein, das mit der Erweiterung allgemeiner Arrays identisch ist. Beispiel:

• Wenn S 1x2x3x4 ist, dann erweitern S(5,2)=struct('a',3) und S(5,2).a=3 S auf 5x2x3x4. Zuvor führte S(5,2).a=3 zu einem 5x24-Array.

• Wenn S 0x5 oder 5x0 ist, dann erweitern S(3)=struct('a',2) und S(3).a=2 S auf 1x3. Zuvor führte S(3).a=1 zu einem 1x5-Array, wenn S 0x5 war, und zu einem 3x1-Array, wenn S 5x0 war.

• Wenn S 0x2x3 ist, dann führen S(3) = struct('a',2) und S(3).a=2 zu Fehlern, weil nicht eindeutig ist, welche Dimension erweitert werden soll. Zuvor führte S(3).a=2 zu einem 1x6-Array.

• Wenn S 1x1x3 mit zwei Feldern ist, dann erweitern S(5)=struct('a',7,'b',[]) und S(5).a=7 S auf 1x1x5. Zuvor führte S(5).a=7 zu einem 1x5-Array.

• Wenn S 0x1 mit zwei Feldern ist, dann erweitern S(5)=struct('a',7,'b',[]) und S(5).a=7 S auf 5x1. Zuvor führte S(5).a=7 zu einem 1x5-Array.

Siehe auch

isfield | table | isstruct | fieldnames | orderfields | rmfield | substruct | cell2struct | struct2cell | struct2table | table2struct | namelengthmax

Themen

• Struktur-Arrays
• Access Data in Nested Structures
• Generieren von Feldnamen aus Variablen