Main Content

La traduzione di questa pagina non è aggiornata. Fai clic qui per vedere l'ultima versione in inglese.

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.

Descrizione

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

esempio

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

esempio

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

espandi tutto

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

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 [].

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

comprimi tutto

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 ... ] (1x100 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 ... ] (1x100 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)

Figure contains an axes object. The axes object with title y = sin(x) contains an object of type line.

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.

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'

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: []

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

Creare una struttura vuota contenente numerosi campi.

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

  0x0 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: []

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: [0x0 struct]

Visualizzare i nomi dei campi di a.b.

fieldnames(a.b)
ans = 2x1 cell
    {'c'}
    {'d'}

Funzionalità estese

Cronologia versioni

Introduzione prima di R2006a

espandi tutto