Structure array

A *structure array* is a data type that groups related data
using data containers called *fields*. Each field can contain any
type of data. Access data in a field using dot notation of the form
`structName.fieldName`

.

When you have data to put into a new structure, create the structure using dot notation to name its fields one at a time:

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

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

You also can create a structure array using the `struct`

function,
described below. You can specify many fields simultaneously, or create a nonscalar
structure array.

`s = struct`

creates a scalar (1-by-1) structure with
no fields.

`s = struct(`

creates a structure array with the specified field and value. The
`field`

,`value`

)`value`

input argument can be any data type, such as a
numeric, logical, character, or cell array.

If

`value`

is*not*a cell array, or if`value`

is a scalar cell array, then`s`

is a scalar structure. For instance,`s = struct('a',[1 2 3])`

creates a 1-by-1 structure, where`s.a = [1 2 3]`

.If

`value`

is a nonscalar cell array, then`s`

is a structure array with the same dimensions as`value`

. Each element of`s`

contains the corresponding element of`value`

. For example,`s = struct('x',{'a','b'})`

returns`s(1).x = 'a'`

and`s(2).x = 'b'`

.If

`value`

is an empty cell array`{}`

, then`s`

is an empty (0-by-0) structure.

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

creates a
structure array with multiple fields.

If none of the

`value`

inputs are cell arrays, or if all`value`

inputs that are cell arrays are scalars, then`s`

is a scalar structure.If any of the

`value`

inputs is a nonscalar cell array, then`s`

has the same dimensions as that cell array. Also, if two or more`value`

inputs are nonscalar cell arrays, then they all must have the same dimensions.For any

`value`

that is a scalar cell array or an array of any other data type,`struct`

inserts the contents of`value`

in the relevant field for all elements of`s`

. For example,`s = struct('x',{'a','b'},'y','c')`

returns`s(1).x = 'a'`

,`s(2).x = 'b'`

,`s(1).y = 'c'`

, and`s(2).y = 'c'`

.If any

`value`

input is an empty cell array,`{}`

, then output`s`

is an empty (0-by-0) structure. To specify an empty field and keep the values of the other fields, use`[]`

as a`value`

input instead.

`s = struct([])`

creates an empty (0-by-0) structure
with no fields.

`s = struct(`

creates a scalar
structure with field names and values that correspond to properties of
`obj`

)`obj`

. The `struct`

function does not
convert `obj`

, but rather creates `s`

as a
new structure. This structure does not retain the class information, so
private, protected, and hidden properties become public fields in
`s`

. The `struct`

function issues a
warning when you use this syntax.

`cell2struct`

| `fieldnames`

| `isfield`

| `isstruct`

| `orderfields`

| `rmfield`

| `struct2cell`

| `struct2table`

| `substruct`

| `table`

| `table2struct`