Main Content

La traducción de esta página aún no se ha actualizado a la versión más reciente. Haga clic aquí para ver la última versión en inglés.

struct

Arreglo de estructuras

Descripción

Un arreglo de estructuras es un tipo de datos que agrupa datos relacionados mediante contenedores de datos llamados campos. Cada campo puede contener cualquier tipo de datos. Acceda a los datos de un campo utilizando notación de puntos con el formato structName.fieldName.

Creación

Cuando tenga los datos que desee incluir en una estructura nueva, cree la estructura utilizando la notación de puntos para nombrar los campos de uno en uno:

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

Los nombres de los campos pueden contener letras ASCII (A-Z, a-z), dígitos (0-9) y guiones bajos, y deben comenzar por una letra. La longitud máxima de un nombre de campo es namelengthmax.

También puede crear un arreglo de estructuras utilizando la función struct, que se describe más abajo. Puede especificar muchos campos al mismo tiempo o crear un arreglo de estructuras no escalar.

Descripción

s = struct crea una estructura escalar (de 1 por 1) sin campos.

ejemplo

s = struct(field,value) crea un arreglo de estructuras con el campo y el valor especificados. El argumento de entrada value puede ser de cualquier tipo de datos, como numérico, lógico, carácter o arreglo de celdas.

  • Si value no es un arreglo de celdas o si value es un arreglo de celdas escalar, s es una estructura escalar. Por ejemplo, s = struct('a',[1 2 3]) crea una estructura de 1 por 1 en la que s.a = [1 2 3].

  • Si value es un arreglo de celdas no escalar, s es un arreglo de estructuras con las mismas dimensiones que value. Cada elemento de s contiene el elemento correspondiente de value. Por ejemplo, s = struct('x',{'a','b'}) devuelve s(1).x = 'a' y s(2).x = 'b'.

  • Si value es un arreglo de celdas vacío {}, s es una estructura (de 0 por 0) vacía.

ejemplo

s = struct(field1,value1,...,fieldN,valueN) crea un arreglo de estructuras con múltiples campos.

  • Si ninguna de las entradas value es un arreglo de celdas o si todas las entradas value que sean arreglos de celdas son escalares, s es una estructura escalar.

  • Si cualquiera de las entradas value es un arreglo de celdas no escalar, s tiene las mismas dimensiones que ese arreglo de celdas. Del mismo modo, si dos o más entradas value son arreglos de celdas no escalares, todas deben tener las mismas dimensiones.

    En el caso de cualquier value que sea un arreglo de celdas escalar o un arreglo de cualquier otro tipo de datos, struct introduce el contenido de value en el campo relevante para todos los elementos de s. Por ejemplo, s = struct('x',{'a','b'},'y','c') devuelve s(1).x = 'a', s(2).x = 'b', s(1).y = 'c' y s(2).y = 'c'.

  • Si cualquier entrada value es un arreglo de celdas vacío, {}, la salida s es una estructura (de 0 por 0) vacía. Para especificar un campo vacío y mantener los valores de los demás campos, utilice [] como entrada value en su lugar.

s = struct([]) crea una estructura (de 0 por 0) vacía sin campos.

s = struct(obj) crea una estructura escalar con nombres de campo y valores que se corresponden con las propiedades de obj. La función struct no convierte obj, sino que crea s como estructura nueva. Esta estructura no conserva la información de clase, por lo que las propiedades privadas, protegidas y ocultas se convierten en campos públicos en s. La función struct emite una advertencia cuando usted utiliza esta sintaxis.

Argumentos de entrada

expandir todo

Nombre de campo, especificado como vector de caracteres o escalar de cadena.

Valores, especificados como cualquier tipo de arreglo. Si cualquier entrada value es un arreglo de celdas no escalar, todas las entradas de arreglos de celdas no escalares tienen las mismas dimensiones.

Si cualquier entrada value es un arreglo de celdas vacío, {}, la salida es un arreglo de estructuras vacío. Para especificar un único campo vacío, utilice [].

La función struct copia las propiedades de obj en los campos de una nueva estructura escalar.

La función struct no crea una estructura a partir de la mayoría de los tipos de datos fundamentales. Por ejemplo, si obj tiene el tipo de datos double o char, struct emite un mensaje de error. Sin embargo, struct sí devuelve las propiedades de una tabla u horario como estructura. Consulte Fundamental MATLAB Classes para ver la lista de tipos de datos fundamentales.

Ejemplos

contraer todo

Guarde fragmentos de datos relacionados en los campos de una estructura. Puede asignar a los campos nombres que describan los datos y que resulten legibles para las personas.

Cree una estructura añadiendo campos utilizando la notación de puntos. Los campos contienen valores x e y de una onda sinusoidal, además de texto que describe los datos.

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 ... ]
        y: [0 0.0634 0.1266 0.1893 0.2511 0.3120 0.3717 0.4298 0.4862 ... ]
    title: 'y = sin(x)'

Represente la onda sinusoidal. Puede referirse a los arreglos de valores x e y por los nombres de los campos. Después, añada el título.

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.

Cree una estructura no escalar que contenga un único campo.

field = 'f';
value = {'some text';
         [10, 20, 30];
         magic(5)};
s = struct(field,value)
s=3×1 struct array with fields:
    f

Visualice el contenido de cada 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

Cuando accede a un campo de una estructura no escalar, como s.f, MATLAB® devuelve una lista separada por comas. En este caso, s.f equivale a s(1).f, s(2).f, s(3).f.

Cree una estructura no escalar que contenga varios campos.

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

Los arreglos de celdas de value2 y value3 son de 1 por 2, por lo que s también es de 1 por 2. Puesto que value1 es un arreglo numérico y no un arreglo de celdas, tanto s(1).f1 como s(2).f1 tienen el mismo contenido. Del mismo modo, puesto que el arreglo de celdas de value4 tiene un único elemento, s(1).f4 y s(2).f4 tienen el mismo contenido.

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'

Cree una estructura que contenga un campo vacío. Utilice [] para especificar el valor del campo vacío.

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

Cree una estructura con un campo que contenga un arreglo de celdas.

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

Cree una estructura vacía que contenga varios campos.

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

  0x0 empty struct array with fields:

    a
    b
    c

Asigne un valor a un campo de una estructura vacía.

s(1).a = 'a'
s = struct with fields:
    a: 'a'
    b: []
    c: []

Cree una estructura anidada en la que a sea una estructura con un campo que contenga otra estructura.

a.b = struct('c',{},'d',{})
a = struct with fields:
    b: [0x0 struct]

Visualice los nombres de los campos de a.b.

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

Capacidades ampliadas

Historial de versiones

Introducido antes de R2006a

expandir todo