As shown in see Basic Usage of Cell Arrays elements can be
extracted from cell arrays using the ‘`{`’ and ‘`}`’
operators. If you want to extract or access subarrays which are still
cell arrays, you need to use the ‘`(`’ and ‘`)`’ operators. The
following example illustrates the difference:

c = {"1", "2", "3"; "x", "y", "z"; "4", "5", "6"}; c{2,3} ⇒ ans = z c(2,3) ⇒ ans = { [1,1] = z }

So with ‘`{}`’ you access elements of a cell
array, while with ‘`()`’ you access a sub array of a cell
array.

Using the ‘`(`’ and ‘`)`’ operators, indexing works for cell
arrays like for multi-dimensional arrays. As an example, all the rows
of the first and third column of a cell array can be set to `0`

with the following command:

c(:, [1, 3]) = {0} ⇒ = { [1,1] = 0 [2,1] = 0 [3,1] = 0 [1,2] = 2 [2,2] = y [3,2] = 5 [1,3] = 0 [2,3] = 0 [3,3] = 0 }

Note, that the above can also be achieved like this:

c(:, [1, 3]) = 0;

Here, the scalar ‘`0`’ is automatically promoted to
cell array ‘`{0}`’ and then assigned to the subarray of `c`

.

To give another example for indexing cell arrays with ‘`()`’, you
can exchange the first and the second row of a cell array as in the
following command:

c = {1, 2, 3; 4, 5, 6}; c([1, 2], :) = c([2, 1], :) ⇒ = { [1,1] = 4 [2,1] = 1 [1,2] = 5 [2,2] = 2 [1,3] = 6 [2,3] = 3 }

Accessing multiple elements of a cell array with the ‘`{`’ and
‘`}`’ operators will result in a comma-separated list of all the
requested elements (see Comma-Separated Lists). Using the
‘`{`’ and ‘`}`’ operators the first two rows in the above
example can be swapped back like this:

[c{[1,2], :}] = deal (c{[2, 1], :}) ⇒ = { [1,1] = 1 [2,1] = 4 [1,2] = 2 [2,2] = 5 [1,3] = 3 [2,3] = 6 }

As for struct arrays and numerical arrays, the empty matrix ‘`[]`’
can be used to delete elements from a cell array:

x = {"1", "2"; "3", "4"}; x(1, :) = [] ⇒ x = { [1,1] = 3 [1,2] = 4 }

The following example shows how to just remove the contents of cell array elements but not delete the space for them:

x = {"1", "2"; "3", "4"}; x(1, :) = {[]} ⇒ x = { [1,1] = [](0x0) [2,1] = 3 [1,2] = [](0x0) [2,2] = 4 }

The indexing operations operate on the cell array and not on the objects
within the cell array. By contrast, `cellindexmat`

applies matrix
indexing to the objects within each cell array entry and returns the requested
values.

- :
`y`=**cellindexmat**`(`

¶`x`,`varargin`) Perform indexing of matrices in a cell array.

Given a cell array of matrices

`x`, this function computesY = cell (size (X)); for i = 1:numel (X) Y{i} = X{i}(varargin{1}, varargin{2}, ..., varargin{N}); endfor

The indexing arguments may be scalar (

`2`

), arrays (`[1, 3]`

), ranges (`1:3`

), or the colon operator (`":"`

). However, the indexing keyword`end`

is not available.**See also:**cellslices, cellfun.