struct

Array di struttura

Descrizione

Un array di struttura è un tipo di dati che racchiude dati correlati mediante contenitori di dati chiamati campi. Ciascun campo può contenere qualsiasi tipo di dati. Per accedere ai dati di un campo si utilizza la notazione a punti nella forma structName.fieldName.

Creazione

Quando si dispone di dati da inserire in una nuova struttura, questa viene creata utilizzando la notazione a punti per denominare i campi uno alla volta:

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

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

I nomi dei campi possono contenere lettere ASCII (A-Z, a-z), cifre (0-9) e trattini bassi e devono iniziare con una lettera. La lunghezza massima del nome di un campo è namelengthmax.

È inoltre possibile creare un array di struttura utilizzando la funzione struct, descritta qui di seguito. È possibile specificare molti campi contemporaneamente o creare un array di struttura non scalare.

Sintassi

s = struct

s = struct(field,value)

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

s = struct([])

s = struct(obj)

Descrizione

s = struct crea una struttura scalare (1x1) senza campi.

s = struct(field,value) crea un array di struttura con campo e valore specificati. L’argomento di input value può essere un qualsiasi tipo di dato, come un array numerico, logico, di caratteri o di celle.

• Se value non è un array di celle o se value è un array di celle scalare, s è una struttura scalare. Ad esempio, s = struct('a',[1 2 3]) crea una struttura 1x1, dove s.a = [1 2 3].

• Se value è un array di celle non scalare, s è un array di struttura con le stesse dimensioni di value. Ciascun elemento di s contiene l’elemento corrispondente di value. Ad esempio, s = struct('x',{'a','b'}) restituisce s(1).x = 'a' e s(2).x = 'b'.

• Se value è un array di celle vuoto {}, s è una struttura vuota (0x0).

s = struct(field1,value1,...,fieldN,valueN) crea un array di struttura con più campi.

• Se nessun input di value è un array di celle o se tutti gli inputi di value che sono array di celle sono scalari, s è una struttura scalare.

• Se uno qualsiasi degli input di value è un array di celle non scalare, s ha le stesse dimensioni dell’array di celle. Inoltre, se due o più input di value sono array di celle non scalari, questi devono avere tutti le stesse dimensioni.

  Per qualsiasi value che consiste in un array di celle scalare o in un array di altro tipo di dati, struct inserisce i contenuti di value nel campo pertinente per tutti gli elementi di s. Ad esempio, s = struct('x',{'a','b'},'y','c') restituisce s(1).x = 'a', s(2).x = 'b', s(1).y = 'c' e s(2).y = 'c'.

• Se qualsiasi input di value è un array di celle vuoto, {}, l’output s è una struttura vuota (0x0). Per specificare un campo vuoto e mantenere i valori degli altri campi, utilizzare invece [] come input di value.

s = struct([]) crea una struttura vuota (0x0) senza nessun campo.

s = struct(obj) crea una struttura scalare con nomi e valori del campo corrispondenti alle proprietà di obj. La funzione struct non converte obj, ma crea s come una nuova struttura. Questa struttura non conserva le informazioni sulla classe, quindi le proprietà private, protette e nascoste diventano campi pubblici in s. La funzione struct genera un avviso quando si utilizza questa sintassi.

Argomenti di input

field — Nome del campo

vettore di caratteri | scalare di stringa

Nome del campo, specificato come vettore di caratteri o scalare di stringa.

value — Valori

array

Valori, specificati come qualsiasi tipo di array. Se qualsiasi input di value è un array di celle non scalare, tutti gli input dell’array di celle non scalare devono avere le stesse dimensioni.

Se qualsiasi input di value è un array di celle vuoto, {}, l’output è un array di struttura vuoto. Per specificare un singolo campo vuoto, utilizzare [].

obj — Oggetto

oggetto

La funzione struct copia le proprietà di obj nei campi di una nuova struttura scalare.

La funzione struct non crea una struttura dalla maggior parte dei tipi di dati fondamentali. Ad esempio, se obj è del tipo di dati double o char, struct genera un messaggio di errore. Tuttavia, struct non restituisce le proprietà di una tabella o di un orario come una struttura. Vedere Fundamental MATLAB Classes per l’elenco dei tipi di dati fondamentali.

Esempi

Memorizzazione di variabili di dati correlate nella struttura

Memorizzare parti di dati correlati nei campi di una struttura. È possibile assegnare ai campi nomi leggibili dall’uomo che descrivono i dati.

Creare una struttura aggiungendovi dei campi mediante la notazione a punti. I campi contengono i valori x e y di un'onda sinusoidale e un testo che descrive i dati.

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)'

Tracciare l’onda sinusoidale. È possibile fare riferimento agli array dei valori x e y tramite i nomi dei campi. Quindi aggiungere il titolo.

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

Struttura con un campo

Creare una struttura non scalare che contenga un campo singolo.

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

s=3×1 struct array with fields:
    f

Visualizzare i contenuti di ciascun elemento.

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

Quando si accede a un campo di una struttura non scalare, come s.f, MATLAB® restituisce un elenco separato da virgole. In questo caso, s.f equivale a s(1).f, s(2).f, s(3).f.

Struttura con più campi

Creare una struttura non scalare che contenga più campi.

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

Gli array di celle per value2 e value3 sono 1x2, pertanto anche s è 1x2. Poiché value1 è un array numerico e non un array di celle, sia s(1).f1 che s(2).f1 hanno gli stessi contenuti. Analogamente, poiché l’array di celle di value4 ha un unico elemento, s(1).f4 e s(2).f4 hanno gli stessi contenuti.

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'

Struttura con un campo vuoto

Creare una struttura che contenga un campo vuoto. Utilizzare [] per specificare il valore del campo vuoto.

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

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

Campi con array di celle

Creare una struttura con un campo contenente un array di celle.

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

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

Struttura vuota

Creare una struttura vuota contenente numerosi campi.

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

s = 

  0×0 empty struct array with fields:

    a
    b
    c

Attribuire un valore a un campo in una struttura vuota.

s(1).a = 'a'

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

Struttura annidata

Creare una struttura annidata, dove a è una struttura con un campo che contiene un’altra struttura.

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

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

Visualizzare i nomi dei campi di a.b.

fieldnames(a.b)

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

Funzionalità estese

Generazione di codice C/C++

Genera codice C e C++ con MATLAB® Coder™.

Note su utilizzo e limitazioni:

• Se l’argomento value è un array di celle, tutti gli elementi devono essere dello stesso tipo.

• I nomi dei campi dell’array struct devono avere la stessa lunghezza. Ad esempio, questo codice presenta un errore in quanto 'my_int' e 'my_double' hanno lunghezze diverse:

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

Ambiente basato su thread

Esegui il codice in background usando MATLAB® backgroundPool oppure accelera il codice con Parallel Computing Toolbox™ ThreadPool.

Questa funzione supporta completamente gli ambienti basati su thread. Per maggiori informazioni, vedere Run MATLAB Functions in Thread-Based Environment.

Cronologia versioni

Introduzione prima di R2006a

R2023b: Visualizzazione dei contenuti parziali, nonché delle grandezze e del tipo di dati degli array nei campi della struttura

Tra le release R2021b e R2023b, MATLAB^® visualizzava l'intero contenuto di un array in un campo struttura, se il contenuto si adattava al display. Se l'array non si adattava, MATLAB mostrava la massima quantità di array consentita dal display.

A partire dalla release R2023b, se l'intero contenuto di un array in un campo non si adatta al display, MATLAB mostra la quantità massima di array consentita dal display, nonché la grandezza e il tipo di dati dell'array. Ad esempio, a partire dalla release R2023b, MATLAB visualizza il contenuto parziale, la grandezza e il tipo di dati di due campi che contengono array di 100 valori doppi.

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)

Se il primo elemento dell'array è troppo grande per essere visualizzato, ad esempio un membro di un'enumerazione con un nome lungo, MATLAB visualizza solo la grandezza e il tipo di dati dell'array.

La funzione disp segue lo stesso comportamento.

R2021b: Visualizzazione di contenuti parziali degli array nei campi struttura al posto della grandezza e del tipo di dati

Prima della release R2021b, MATLAB visualizzava l'intero contenuto di un array in un campo struttura, se il contenuto si adattava al display. Se l'array non si adattava, MATLAB mostrava la grandezza e il tipo di dati dell'array.

A partire dalla release R2021b, se l'intero contenuto di un array non si adatta al display, MATLAB mostra la quantità massima di array consentita dal display, anziché la grandezza e il tipo di dati. Ad esempio, a partire dalla release R2021b, MATLAB visualizza il contenuto parziale di due campi di struttura che contengono array di 100 valori doppi.

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 … ]

Se il primo elemento dell'array è troppo grande per essere visualizzato, ad esempio un membro di un'enumerazione con un nome lungo, MATLAB visualizza solo la grandezza e il tipo di dati dell'array.

La funzione disp segue lo stesso comportamento.

R2019a: Coerenza dell’espansione dell'array di struttura con l'espansione dell'array generale

A partire dalla release R2019a, le dimensioni di un array di struttura espanse sono coerenti sia che si attribuisca un valore a un singolo campo utilizzando la notazione a punti sia che si attribuisca un’intera struttura all’array. In precedenza, le dimensioni di output erano diverse quando non si specificavano gli indici per tutte le dimensioni. L’attribuzione a un campo tramite la notazione a punti corrisponde adesso al comportamento precedente di attribuzione alla struttura, che è coerente con l'espansione generale degli array. Ad esempio:

• Se S è 1x2x3x4, S(5,2)=struct('a',3) e S(5,2).a=3 espandono entrambe S a 5x2x3x4. In precedenza, S(5,2).a=3 restituiva un array 5x24.

• Se S è 0x5 o 5x0, S(3)=struct('a',2) e S(3).a=2 espandono entrambe S a 1x3. In precedenza, S(3).a=1 restituiva un array 1x5 quando S era 0x5 e un array 3x1 quando S era 5x0.

• Se S è 0x2x3, S(3) = struct('a',2) e S(3).a=2 producono errori perché non è chiaro quale dimensione espandere. In precedenza, S(3).a=2 restituiva un array 1x6.

• Se S è 1x1x3 con due campi, S(5)=struct('a',7,'b',[]) e S(5).a=7 espandono entrambe S a 1x1x5. In precedenza, S(5).a=7 restituiva un array 1x5.

• Se S è 0x1 con due campi, S(5)=struct('a',7,'b',[]) e S(5).a=7 espandono entrambe S a 5x1. In precedenza, S(5).a=7 restituiva un array 1x5.

Vedi anche

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

Argomenti

• Structure Arrays
• Access Data in Nested Structures
• Generazione dei nomi dei campi dalle variabili