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 estructura

Descripción

Un arreglo de estructura es un tipo de datos que agrupa datos relacionados usando contenedores de datos denominados 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 estructura utilizando la función struct, que se describe más abajo. Puede especificar muchos campos al mismo tiempo o crear un arreglo de estructura no escalar.

Sintaxis

s = struct

s = struct(field,value)

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

s = struct([])

s = struct(obj)

Descripción

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

s = struct(field,value) crea un arreglo de estructura 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 estructura 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.

s = struct(field1,value1,...,fieldN,valueN) crea un arreglo de estructura 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

field — Nombre de campo

vector de caracteres | escalar de cadena

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

value — Valores

arreglo

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 estructura vacío. Para especificar un único campo vacío, utilice [].

obj — Objeto

objeto

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

Guardar variables de datos relacionados en una estructura

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)

Estructura con un campo

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.

Estructura con múltiples campos

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'

Estructura con un campo vacío

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

Campos con arreglos de celdas

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

Estructura vacía

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

Estructura anidada

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

Generación de código C/C++

Genere código C y C++ mediante MATLAB® Coder™.

Notas y limitaciones de uso:

• Si el argumento value es un arreglo de celdas, todos los elementos deben ser del mismo tipo.

• Los nombres de los campos de un arreglo de estructura deben tener la misma longitud. Por ejemplo, este código genera un error porque 'my_int' y 'my_double' presentan distintas longitudes:

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

Entorno basado en subprocesos

Ejecute código en segundo plano con MATLAB® backgroundPool o acelere código con Parallel Computing Toolbox™ ThreadPool.

Esta función es totalmente compatible con entornos basados en subprocesos. Para obtener más información, consulte Run MATLAB Functions in Thread-Based Environment.

Historial de versiones

Introducido antes de R2006a

R2019a: La expansión del arreglo de estructura es consistente con la expansión general de arreglos

A partir de la versión R2019a, las dimensiones de un arreglo de estructura expandido son consistentes tanto si se asigna un valor a un único campo utilizando la notación de puntos como si se asigna una estructura completa al arreglo. Anteriormente las dimensiones de salida eran diferentes cuando no se especificaban índices para todas las dimensiones. La asignación a un campo utilizando la notación de puntos coincide con el comportamiento anterior de asignación a una estructura, lo que es consistente con la expansión del arreglo general. Por ejemplo:

• Si S es de 1 por 2 por 3 por 4, S(5,2)=struct('a',3) y S(5,2).a=3 expanden S a 5 por 2 por 3 por 4. Anteriormente, S(5,2).a=3 resultaba en un arreglo de 5 por 24.

• Si S es de 0 por 5 o 5 por 0, S(3)=struct('a',2) y S(3).a=2 expanden S a 1 por 3. Anteriormente, S(3).a=1 resultaba en un arreglo de 1 por 5 si S era de 0 por 5 y en un arreglo de 3 por 1 si S era de 5 por 0.

• Si S es de 0 por 2 por 3, S(3) = struct('a',2) y S(3).a=2 producen errores porque no queda claro qué dimensión expandir. Anteriormente, S(3).a=2 resultaba en un arreglo de 1 por 6.

• Si S es de 1 por 1 por 3 con dos campos, S(5)=struct('a',7,'b',[]) y S(5).a=7 expanden S a 1 por 1 por 5. Anteriormente, S(5).a=7 resultaba en un arreglo de 1 por 5.

• Si S es de 0 por 1 con dos campos, S(5)=struct('a',7,'b',[]) y S(5).a=7 expanden S a 5 por 1. Anteriormente, S(5).a=7 resultaba en un arreglo de 1 por 5.

Consulte también

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

Temas

• Arreglos de estructuras
• Acceder a datos en estructuras anidadas
• Generar nombres de campo desde variables
• Diferencias entre arreglos de celdas y de estructuras

×

Abrir ejemplo

Tiene una versión modificada de este ejemplo. ¿Desea abrir este ejemplo con sus modificaciones?

No, sobrescribir la versión modificada Sí