A = cell(20,11); size(A) ans = 20 11 works for me... ? Or do you want the size of the contents of each cell? cellsz = cellfun(@size,A,'uni',false); *Addendum per comment:* I still am not getting what you want. clear A >> A{1} = single(ones(4)); >> A{2} = uint8(toeplitz(1:10)); >> A{3} = 'Hello World' A = [4x4 single] [10x10 uint8] 'Hello World' >> size(A) ans = 1 3 >> cellsz = cellfun(@size,A,'uni',false); >> cellsz{:} ans = 4 4 ans = 10 10 ans = 1 11

Yes, there is necessary overhead for cell arrays. Note that |whos| (which your |getsize| uses|) does not actually show all the memory used by variables. By necessity a cell array cannot just store the content of the data (your 2 bytes consumed by 'a'). It also needs to store: * where that content is actually stored in memory (since the content of the cell array can be anything, the content is not actually stored inside the cell array, just a pointer to the content) * the matrix header for that content which includes: * the type of content * how many dimensions that content has * the length of each dimension of that content This result in an overhead of 112 bytes per non-empty cell (empty cells only need 8 bytes to store a null pointer) To that you need to add more bytes that |whos| doesn't show and that are required for every variable in matlab: * the type of the variable (i.e it's a cell array) * how many dimensions that variable has * the length of each dimension

As a rule, I would never use |length| because it is often used incorrectly (on a matrix). For a vector I'd use |numel|. In my opinion, |length| should be deprecated. To get the number of rows of the matrix stored in |NumL{i}| you use |size| with the dimension set to 1: numrows = size(NumL{i}, 1);

You can use the cellfun command: cellfun(@size,myCell,'UniformOutput',false)

x{1,1}{1,1} = 1; x{1,1}{2,1} = [2;3;4]; x{2,1}{1,1} = [3;1]; x{2,1}{3,1} = [1;5;2;4]; The trivial answer: length(x{1,1}{1,1}) length(x{2,1}{3,1}) To get all lengths at once: Len = cellfun(@(c) cellfun('length', c), x, 'UniformOutput', false) Now |Len{2}(3)| is 4.

This should work

A = {rand(2,3), rand(3,3), rand(2,4)}
% Find the maximum numbers rows (dims(1)) and the maximum number of columns (dims(2))
dims = max(cell2mat(cellfun(@(x)size(x), A, 'uni', 0)'));
%Pad each element of A with zeros so that it's size becomes dims
B = cellfun(@(x)[x,zeros(size(x,1),dims(2)-size(x,2));zeros(dims(1)-size(x,1),dims(2))], A,'uni', 0)

This results in

B = 

    [3x4 double]    [3x4 double]    [3x4 double]

And more specifically:

>> B{1}

ans =

    0.9028    0.5791    0.0366         0
    0.5763    0.0658    0.3373         0
         0         0         0         0

>> B{2}

ans =

    0.0764    0.1326    0.4413         0
    0.2463    0.0238    0.3726         0
    0.0299    0.2610    0.1408         0

>> B{3}

ans =

    0.6266    0.6141    0.5653    0.5951
    0.3176    0.0741    0.5795    0.2600
         0         0         0         0

C = arrayfun(@(x)rand(randi([1 20],1,2)),(1:8)','un',0);% example [s,d] = cellfun(@size,C); out = max([s,d]);

max(cellfun(@length, YourCell))

cellfun('length',a)

"apply length(x) to each element x in a".

cellfun docs.

The most memory efficient way is the following without a loop: C(1:n) = {'red'}; % Assuming C doesn't exist yet (EDITED) That is because in the above line, all n copies of the 'red' string are reference copies of each other (like a shared data copy), so the memory footprint is smaller than filling each cell individually with a brand new allocated string in a loop. Having said that, I strongly suspect that what you are attempting to do is futile. If you change any of the individual 'red' strings downstream in your code you will probably need to allocate brand new cell element variables anyway, so this pre-allocation of 'red' would be useless (actually wastes time) regardless of the methoud you use to create C in the first place (my method or with a loop). The only exceptions would be if you don't plan on altering C at all downstream, or if you plan to operate on each string "in-place" ... i.e., changing the contents of the string directly without changing its length, etc. Can you elaborate on what you intend to do with C downstream in your code?

A MATLAB variable consists of: Structure (about 60 bytes on a 32-bit system, a bit more on 64-bit systems) containing information such as: - Class - Type (temporary, normal, sub-element, etc) - Dimensions - Pointers to data (real & imaginary) - Pointers to sparse indexing (if applicable) - Pointers to field names (for structs) - A few other things A double variable is all of the above, with data pointer(s) pointing to an array of double data. A single variable is all of the above, with data pointer(s) pointing to an array of single data. A char variable is all of the above, with data pointer pointing to an array of char data (2-bytes per char, btw). Etc. A cell array is all of the above, with data pointer pointing to an array of other MATLAB variable pointers. E.g., in a double class variable, the "data" of the variable is 64-bit IEEE double precision values. For a cell array, the "data" of the variable is 32-bit pointers to the 60-byte variable structures of other variables (64-bit pointers on 64-bit systems) When you create a cell array with the cell function, e.g., A = cell(1,2); The variable A is all of the above, but the "data" of the cell array variable is an array of all NULL pointers (0). I.e., there is really nothing there at all. When you de-reference such an array like this: A{1,1} MATLAB actually creates a brand new empty double matrix on the fly. When you fill a cell array element with an explicit empty double matrix like this: B{2} = []; MATLAB creates a brand new cell array B (assuming B did not already exist) with two data elements. The first element is actually NULL (0) and nothing is there. The second element actually has a variable pointer in it that is not NULL ... it points to another MATLAB variable that happens to be an empty double matrix. The B elements *look* a lot like variable A elements above (empty double matrices), but behind the scenes they are stored differently as outlined above. But even though they are stored differently behind the scenes, the isequal function still considers the elements equal since the NULL pointers get virtually equated to physically present empty matrices. If you fill a cell element with something like this: B{1} = [1 2 3]; MATLAB creates a shared data copy of the right-hand-side and puts the pointer to this shared data copy into the first data spot of B. When you subsequently de-reference the cell array element like this: B{1} MATLAB considers this an expression and evaluates it as a shared data copy of the variable that is actually in the B{1} spot. A struct array is *very* similar to a cell array in that the "data" of a struct array is pointers to the 60-byte structures of other MATLAB variables. The difference is the extra complication of indexing into the data elements via the field names. Also, you need to be very careful using the whos function when comparing variable memory footprints, since the whos function does not take into account variable sharing. E.g., consider the following formulations for A and B and the subsequent whos command: >> A = cell(1,1000); >> A(:) = {1:1000}; >> B = cell(1,1000); >> for k=1:1000; B(k) = {1:1000}; end >> whos Name Size Bytes Class A 1x1000 8060000 cell array B 1x1000 8060000 cell array k 1x1 8 double array Grand total is 2002001 elements using 16120008 bytes >> isequal(A,B) ans = 1 It sure looks like A and B take the same amount of memory, and in fact their data is equal according to the isequal function. But in fact the actual memory footprint for A is *much* smaller than the memory footprint for B. That is because the data elements of A, the pointers themselves, are in fact exactly equal to each other ... i.e. all 1000 elements of A point to exactly the same MATLAB variable (sub-element sharing aka reference copy). But in variable B, each element was created new each time through the loop and thus it is a brand new variable that takes more storage. The memory footprint for B really *is* very large as indicated. To see this: >> feature memstats Physical Memory (RAM): In Use: 3545 MB (dd990000) >> clear A >> feature memstats Physical Memory (RAM): In Use: 3545 MB (dd964000) >> clear B >> feature memstats Physical Memory (RAM): In Use: 3537 MB (dd1e5000) Clearing A didn't do much of anything to the actual used memory, but clearing B sure did !