Esta página aún no se ha traducido para esta versión. Puede ver la versión más reciente de esta página en inglés.

struct

Descripción

Un array de estructura es un tipo de datos que agrupa datos relacionados mediante contenedores de datos denominados campos . Cada campo puede contener cualquier tipo de datos. Acceda a los datos en un campo utilizando la notación de puntos del formulario structName.fieldName.

Creación

Cuando tenga datos para poner en una nueva estructura, cree la estructura utilizando la notación de puntos para nombrar sus campos uno a la vez:

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

También puede crear una matriz de estructura mediante la función struct , que se describe a continuación. Puede especificar varios campos simultáneamente o crear una matriz de estructura no escalable.

Descripción

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

ejemplo

s = struct(field,value) crea una matriz de estructura con el campo y los valores especificados. El argumento de entrada value puede ser cualquier tipo de datos, como un array numérico, lógico, de carácter o de celda.

  • Si value es no una matriz de celdas, o si value es una matriz de celdas escalares, s es una estructura escalar. Por ejemplo, s = struct('a',[1 2 3]) crea una estructura 1 por 1, donde s.a = [1 2 3].

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

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

ejemplo

s = struct(field1,value1,...,fieldN,valueN) crea varios campos. Cualquier matriz de celdas no escalar del conjunto value1,...,valueN debe tener las mismas cotas.

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

  • Si alguna de las entradas de value es una matriz de celdas no escalar, s tiene las mismas dimensiones que la matriz de celdas no escalar. Para cualquier value que sea una matriz de celdas escalares o una matriz de cualquier otro tipo de datos, struct inserta el contenido de value en el campo correspondiente para todos los elementos de s .

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

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

s = struct(obj) crea una estructura escalar con nombres de campo y valores que corresponden a las propiedades de obj. La función struct no convierte obj, sino que crea s como una nueva estructura. 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 al utilizar esta sintaxis.

Argumentos de entrada

expandir todo

Nombre de campo, especificado como vector de carácter. Los nombres de campo válidos comienzan con una letra y pueden contener letras, dígitos y guiones subrayados. La longitud máxima de un nombre de campo es el valor que devuelve la función namelengthmax .

Valores, especificados como cualquier tipo de Array. Si alguna entrada value es una matriz de celdas no escalar, todas las entradas de matriz de celdas no escalar deben tener las mismas dimensiones.

Si cualquier entrada value es una matriz de celdas vacía, {}, el resultado es una matriz de estructura vacía. Para especificar un único campo vacío, utilice [].

Object, especificado como escalar o matriz de objetos. La función struct copia las propiedades de obj en los campos de una nueva estructura escalar. La mayoría de los tipos de datos fundamentales, como double o char, no se admiten. Vea Las clases fundamentalesMATLAB para la lista de tipos de datos fundamentales.

Ejemplos

contraer todo

Almacene trozos de datos relacionados en los campos de una estructura. Puede dar a los campos nombres legibles por humanos que describen los datos.

Cree una estructura agregando campos a él mediante notación de puntos. Los campos contienen valores x e y para una onda sinusoidal y 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: [1x100 double]
        y: [1x100 double]
    title: 'y = sin(x)'

Traza la onda sinusoidal. Puede hacer referencia a los arrays de valores x e y por sus nombres de campo. A continuación, añada el título.

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

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

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

Ver 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 se 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 escalable 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 = 1x2 struct array with fields:
    f1
    f2
    f3
    f4

Los arrays de celdas para value2 y value3 son 1 por 2, por lo que s también es 1 por 2. Dado que value1 es una matriz numérica y no una matriz de celdas, tanto s(1).f1 como s(2).f1 tienen el mismo contenido. De manera similar, debido a que la matriz de celdas para 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 una matriz 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, donde a es una estructura con un campo que contiene otra estructura.

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

Vea los nombres de los campos de a.b.

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

Capacidades ampliadas

Introducido antes de R2006a