You pre-allocate only the cell: C = cell(1, 12); There is no need to pre-allocate the elements of the array, because you can pre-allocate the arrays, when you create them. When you assign them to the cell element, the former contents is overwritten. Therefore pre-defining the cell elements is not a pre-allocation, but a waste of memory.

You can do this with deal().

>> [X{1:3, 1}] = deal(zeros(3))

X = 

    [3x3 double]
    [3x3 double]
    [3x3 double]

myCell(1,:) = {0} * Left hand side: use () to keep it as cells not braces for extraction of the content of cells. * Right handside: make 0 a 1x1 cell so that it can be stuck into all of the cells on the left via scalar expansion

a=cell(1,2,3)

repmat also works for cell arrays C = repmat({nan(1, 200)}, 10, 3)

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?

[c{1,1:32}] = deal(cell(1,3)); or simpler: [c{:}] = deal(cell(1,3)); or even just: c = repmat({cell(1,3)},1,32) See: